Part 2. How you get an AI product from prototype to governed enterprise scale without the review board becoming your roadmap.
For years I built customer-facing products in pharma, where nothing we shipped reached a customer until it had cleared medical, legal and regulatory review.
I was never an MLR (medical, legal, and regulatory) reviewer. I was downstream of them, the person whose platforms produced the content that went into the queue, which means what I learned was the cycle time: how long a change took to clear, how much rework came back, and how differently you design a system when you know every output has to survive someone else’s scrutiny.
Then I left, built an agentic AI platform, and shipped a system that writes brand-new sentences to real customers dozens of times a day, with nothing resembling that review anywhere in it.
In part one I argued that the artifact a product manager produces is the story, not the spec. I still believe it. But the story is what gets you to the right product. It is not what gets that product through an architecture board, a compliance review and an enterprise security assessment, which is where I have watched many promising AI pilots quietly stall.
Three artifacts do that work. In my experience they now belong to product, and most job descriptions have not caught up.
Artifact 1: The context policy
Traditional software behaves the same way for every user because the logic is fixed. Agentic software behaves differently for every user because the context is different. What the model knows at the moment it acts determines what it does.
So the governing question of an AI product becomes: what does this agent know about this customer right now, and who decided that?
That looks like an engineering question. It gets filed as one. Which is how you end up with your product’s behavior determined by whoever wrote the retrieval code.
On the platform I run today, the agent talking to a homeowner works on behalf of one specific local business. It needs that business’s service area, the services it actually offers, its hours, the jobs it refuses, its seasonality, and the history with this particular customer. Memory is layered on purpose: working memory for the live conversation, episodic for what happened with this lead before, semantic for what is true about this business, procedural for how this business wants things done. In production, every answer is grounded in that business’s own content rather than in the model’s general knowledge of the trade.
Every layer there is a product decision with a business consequence:
- What must always be in context. A painting business that does not do interiors in summer should never have an agent implying otherwise.
- What gets retrieved on demand, and what the agent does when retrieval comes back empty. The honest fallback, “let me get the owner to confirm that,” is a designed behavior, not an accident.
- What must never enter context. This is where a privacy policy stops being a document and becomes a system boundary you can show an assessor.
In review terms, context is the reference pack. A claim without a source does not ship. An agent sentence that cannot be traced to something the business actually told us is the same failure, just faster and at higher volume.
If you cannot describe your context policy in a page, you do not own your product’s behavior.
Artifact 2: Capabilities as components, not prompts
The first version of anything agentic is prompts scattered across a codebase. It works. It is also unreviewable, because the behavior of the product does not exist anywhere as an object you can point at.
The fix is to treat each capability as a versioned component with a contract: what it is for, what inputs it needs, which tools it may call, what it must never do, what shape its output takes, and who signed off.
Qualifying a lead is a component. Following up on a lead that has gone quiet is a component. Producing a scope from a conversation will be one. They get assembled per business, per vertical, and per level of autonomy that owner has granted.
Pharma faced a related governance problem years ago, and one response was modular content. Rather than reviewing every asset from scratch, you build a library of approved modules, review at the module level, and assemble assets from pre-approved parts. Review once, reuse many times, and always know what is inside anything you shipped.
The payoff is the same for agents:
- Reuse. Lead qualification built for cleaning mostly works for painting with the trade-specific questions swapped.
- Review. Compliance reviews one component instead of four hundred prompt strings.
- Rollback. When behavior degrades you revert a component, not a release.
- Attribution. When an agent says something strange, you know which component said it.
Product owns the contract: the boundary, the permitted actions, the escalation rule. Engineering owns the implementation. Blur that and your boundaries drift silently with every refactor.
Artifact 3: The eval suite, which is the release gate
Here is the thing that took me too long to internalize.
Traditional software fails loudly. Agents fail plausibly.
A broken app throws an error and someone files a ticket. An agent that misreads a customer produces a fluent, confident, entirely reasonable-sounding reply that quietly loses the job. Nothing alerts. The dashboards stay green. The only evidence is a conversation nobody reads.
That is what evals are for. Three layers, all of which I run:
A golden set. A fixed collection of real conversations and edge cases that every change to a prompt, an agent or a model runs against before it ships. The point is not proving the new version is perfect. The point is proving it did not get worse at something it used to handle. Skipping this is how teams ship an “improvement” that breaks a behavior customers depended on.
Automated scoring. A grading model scores outputs against criteria we set: did it ask the qualifying questions this trade requires, did it stay inside the services this business offers, did it avoid committing to a price nobody authorized, did it escalate when it should have. On conversational products I have built before, the dimensions that mattered most were safe escalation and triage, and factual groundedness. Those criteria are a product artifact. The PM writes them. Not the model, and not the engineer who implements the grader.
Traces and human reading. Automated scores tell you the rate. They never tell you what happened. I trace runs and read real transcripts, because the sentence that reorganizes a roadmap has never once appeared in an aggregate.
And the hardest lesson, which I learned in production rather than in a test suite: your evals only cover what you thought to put in them.
Two real failures from my own platform. An agent once claimed a business offered a service it does not offer, which is the failure everyone expects and the one evals catch. The second one was worse. A lead came in, the agent answered correctly, the CRM record was created, and the owner never found out, because they had turned off SMS notifications. Every model output in that chain was good. The eval suite had nothing to say about it. The product failed anyway.
The eval suite grades the model. Only production grades the system. A mature eval practice includes the step most teams skip: when something escapes, the fix is not only the bug, it is the new eval case so that failure can never return quietly.
Evals are also how you say no. The best use I have made of them is holding a launch. I held back scaling a conversational product to new areas until answer accuracy came up, and I held a paid acquisition feature because customers were already getting results without it. Both of those were unpopular calls that were easy to defend, because the criteria were written down before the argument started.
Speed and governance are not opposites
Most enterprises I talk to have the same shape of problem. Leadership wants time to value measured in weeks. The architecture board, the business review and the AI governance board each want their turn. Teams conclude they must choose between shipping fast and shipping safely, and they end up doing neither: six months of review for a pilot that was never instrumented well enough to prove value.
These three artifacts are how you get both, and the sequencing is the whole trick.
Agree the eval criteria before you build, not after. Take legal, compliance and the business the criteria your agent will be graded against, while it is still cheap to change. Review then becomes a check against agreed criteria rather than an open-ended debate about whether AI is safe. You are no longer asking a review board to trust you. You are showing them the pass bar they themselves signed off on, and the last run against it.
Make the component the unit of approval. Get a component approved once and every future assembly inherits it. Review effort stops scaling with the number of features you ship.
Instrument time to value from day one. On my own platform I track how long a new customer waits for their first result, and I hold the product to inside 30 days. Pilots that cannot answer “what did this produce, by when” are the ones that get killed in the second budget cycle, no matter how good the demo was.
Prototype in days, then design. Cheap building is real: I prototype with AI coding tools and have working software in an afternoon. What has not gotten cheaper is judgment, and governance is judgment with a paper trail.
The sentence I would put on a wall:
A compliance constraint that is not an eval case is a hope.
“The agent must never quote a price” is a meeting. A case in the golden set, with a pass bar and a run history, is a control. Turning the first into the second is the highest-leverage thing an AI PM does, and it is why this role now sits closer to quality engineering than to roadmap administration.
Who owns what
Product owns the purpose and core actions, the context policy, the component contracts and their boundaries, the eval criteria and the pass bar, the escalation and approval design, and the decision to ship or hold.
Engineering owns orchestration, retrieval, sandboxing and permissions, latency and cost, observability, and fast rollback.
Legal and compliance own what may be claimed, how data is handled and retained, what must be disclosed, and how long evidence is kept.
The business owns the outcome metric, and owes you an honest one.
The seam between them is the actual job. In my case the seam is also my desk: I am a solo founder, so I play all four roles, which means I feel every collision personally and have nobody else to blame when the wrong hat wins. Running an AI product that way for two years has taught me more about where those boundaries belong than a decade of reading about them did.
The artifact, revisited
Part one ended on the question Reid Hoffman asked Josh Elman: what artifact does a product manager produce?
The story is still the answer for what to build. Nothing about AI changed that, and the products that skip it feel hollow within thirty seconds.
But AI added a second half to the job. When your product generates its behavior instead of following it, somebody has to own what it knows, what it may do, and how you would prove any of it to a reviewer who was not in the room. Engineering can build all of that. It should not be the one deciding it.
Pharma took decades to build MLR into something that works, and people still complain about it, because the cost of review is visible every day and the cost of what it prevents never shows up on a dashboard. Agentic products are the fastest, highest-volume version of that same problem, and we are only a few years into inventing our answer to it.
So: ship the story. Keep the receipts.
Part one: I wrote the perfect spec. Nobody wanted the product.
I’m Arun Thachi. I build agentic AI products hands-on, with LangGraph, retrieval and MCP-based tool calling, after 20 years in enterprise technology including 11 in pharma, where I led omnichannel and conversational AI products through regulated review and into production. If you are running evals on an agentic product inside an enterprise, I would like to hear where you drew the line between product and engineering ownership.
