The ordinary software project begins with a small act of surrender. Someone who understands the problem explains it to someone who understands the code. The explanation becomes a ticket; the ticket joins a backlog; the backlog acquires the geological dignity of a mountain range. Weeks later, everybody gathers to admire a screen that is almost, but not quite, what anyone meant. Saurabh Anand has made a career bet against this ritual.
As Head of Product at Emergent, Anand works on a platform where a person describes an application and a collection of AI agents designs, codes and deploys it. The proposition sounds breezy. The product problem is anything but. A chat box can make software creation look like conversation; behind it sit databases, authentication, payments, integrations, tests and the long parade of edge cases that reality sends to punish an attractive demo.
This is why Anand's most useful public idea is not about speed. It is about degrees of agency. He divides the field into wrappers, workflows and agents. A wrapper puts a tailored interface around a model. A workflow passes outputs along a route. An agent loops: it acts, observes, adjusts and tries again. In his formulation, the builder is no longer merely writing steps. The builder is shaping judgment.
“Wrappers give you UX. Workflows give you motion. Agents give you autonomy.”Saurabh Anand
Wrapper
A model wears a specialized interface. Useful presentation, limited new behavior.
Workflow
Outputs trigger the next node. Motion arrives, but the route remains largely predetermined.
Agent
The system observes and adjusts inside ambiguity. Autonomy arrives with responsibility.
A product manager for the exception
Anand's framework gets interesting where the diagram stops behaving. A workflow likes a clean input and a known branch. Work, regrettably, has met neither. A supplier uploads the wrong document. A customer explains the problem sideways. An approval depends on a fact missing from the form. Anand writes about the stubborn fraction of cases that break the tree and make a supposedly intelligent product feel rather dim.
Product management has always lived among exceptions. In an agentic product, however, exceptions cease to be a footnote and become the main stage. If software can choose its next step, the product team must decide what it may choose, what it must remember, when it should ask and how it should recover. The interface may be plain English. The design material is judgment.
That helps explain Anand's recurring emphasis on trust. At an Inside Emergent gathering in Bengaluru, his subject was the move from AI features to AI products and the construction of experiences users trust. The surrounding sessions dealt with memory, evaluation, orchestration and reliability. These are not the words of a magic show. They are the vocabulary of people tidying the theatre after the rabbit has escaped.
When the estimate came back as an app
There is an office story that captures the tempo. Anand asked engineer Pritam Sharma how long it would take to build an Emergent mobile app. Sharma did not return with a schedule. After working through the night, he sent a screen recording of a functioning app. The sun was up; the daily stand-up was beginning; his apology for missing it came attached to the thing the meeting would have discussed.
The anecdote would be unbearable if it ended there, a fable about caffeine and solitary genius. It does not. Sharma's prototype needed a squad. Aditya Morarka coordinated the sprint; Hament Choudhary and Sanjana Yalamarthi refined the interface and code; Ankit Soni tested it. Two weeks after Anand's question, the app was live in the stores. The overnight build was the spark. Shipping was a team sport.
Anand asks for a timeline for the mobile app.
A working prototype and screen recording arrive.
A cross-functional squad turns the prototype into an app-store release.
It is a neat illustration of how AI changes product work without abolishing it. When a first version becomes cheaper, the conversation begins earlier. A team can argue with a functioning object instead of a document. But speed merely brings the hard questions forward: Is the flow coherent? Does the code hold? What breaks? Can somebody besides the author use it without supervision? The prototype is no longer the finish line. It is the opening sentence.
The domain expert gets the keyboard
Anand's examples are revealingly unglamorous. A supply-chain manager needs a portal where vendors submit documents, approvals move and status remains visible. An operations lead needs a resource-request system. A product manager needs customer feedback tagged and summarized. A support team needs tickets classified and routed. None will set a conference stage ablaze. Each can quietly consume a week.
For decades, businesses have answered these small, specific needs with spreadsheets, generic software or a request to engineering. The person closest to the problem usually becomes a petitioner. Emergent's bet reverses the relationship: the operator describes the system and the system gets built. Anand has called the result “idea to deployed in hours, not sprints.” The phrase matters because it moves authority toward the person who knows the workflow, even if that person has never learned the stack.
He tested the pattern in public after a friend struggled to get a résumé past applicant-tracking systems. Anand inspected the formatting traps, keyword rules and parsing quirks, then built a tool on Emergent that compared a résumé with a job description, identified problems and produced an ATS-safe version. The interesting part was not that another résumé utility existed. It was that a product operator could encounter a particular frustration and manufacture a response before the frustration went cold.
“You're not writing steps anymore. You're shaping judgment.”Saurabh Anand
Ambition with a ledger attached
Anand studied at IIT Roorkee from 2014 to 2018. His public biography is otherwise sparing; his writing prefers mechanisms to memoir. Even his most expansive ambition arrives as arithmetic. When Emergent announced its $130 million Series C in July 2026, at a valuation of $1.5 billion, Anand asked what it would take to train a frontier model from India. His answer began with the cost, close to a billion dollars for one frontier training run by his estimate, and the distance still to travel.
The route he described was sequential: build something millions use, earn revenue, earn belief, then earn compute. There is no smallness in that ambition, but there is a product manager's order to it. Adoption precedes permission. Utility finances reach. The grand destination is approached through the prosaic work of making an app behave.
By the company's count, more than 12 million applications had been built on Emergent by the Series C announcement. Such numbers invite triumph, and also scrutiny. Twelve million beginnings are not twelve million durable products. The useful question for Anand's team is what happens after generation: when a payment fails, a user changes course or a business becomes dependent on the tool it described over lunch.
That tension gives Anand's work its shape. He is widening the front door to software while attending to the hinges. The language of AI frequently treats friction as an embarrassment to be erased. Product people know better. Some friction is evidence: a user hesitating, a system asking for confirmation, a test refusing to pass. Trust does not come from pretending the difficult parts have vanished. It comes from handling them visibly and well.
After the prompt
The charming story of generative software is that an idea becomes an app. The more consequential story begins one minute later. The app meets a user. The user does something inventive, impatient or wrong. The agent has to decide. Somewhere behind the conversational surface, somebody had to think about that decision before it arrived.
This is where Anand appears most at home: after the spectacle, before the habit. His public voice is concise and schematic, fond of short ladders and sharp distinctions. Yet the destination is human. The shop owner should not need to become a software company. The operations manager should not have to plead with a backlog. The founder should be able to test an idea while it still feels urgent.
If the bet works, programming does not disappear; it moves into the platform, the guardrails and the judgment of agents. Product management moves too. Its finest skill may no longer be translating a user into a specification. It may be teaching a system how to remain useful when the specification runs out. Software has always been logical. Anand is working on the part where it learns to cope with people.
There is a modesty hidden inside that formidable project. It begins by admitting that users will always surprise the system and that intelligence without restraint is merely confidence with a larger budget. Anand's version of progress is therefore not a flawless first answer. It is a product that notices, corrects and keeps enough context to do better on the next turn. The promise of agents rests less on their ability to perform magic than on their willingness to clean up after themselves.