Reproducible AI in Healthcare: The Same Question Should Get the Same Answer

by Kaushal Parikh, VP of Product Management – AI Platform, Komodo Health

The Rerun That Didn’t Match

An analyst refreshes last quarter’s patient count for a brand review and gets a different number. Nothing in the market changed. The team spends three days working out whether the data refreshed or the method drifted, and the review slips by a week.

Those two causes look identical on a chart, but only one of them is acceptable. A data refresh is expected. A method that drifted means the earlier number can’t be defended either, and a skeptical reader will treat one unexplained change as a reason to doubt the rest.

We hit a version of this in our own testing in October. A user took the SQL behind a MarmotTM Navigator analysis and ran it in Marmot Builder. It failed because the notebook resolved table names with a schema prefix that Navigator had left implicit. Same question, same data, same query, and it didn’t run. It’s a small thing to fix, and it’s also exactly the kind of gap that turns a reproducible analysis into one that only works where it originated.

Our last post on explainable AI in healthcare put the definition on the page so a reviewer can follow the path to a number. Reproducible AI in healthcare keeps that definition the same every time it runs, and when the number changes, it shows why.

AI Output Varies, Deterministic Code Stays the Same

Everyone building with large language models knows that AI outputs vary from run to run, a property called nondeterminism. Ask the same question twice and the wording, the steps, and sometimes the answer itself come back differently. For evidence work, that disqualifies the raw output as the deliverable.

The code an AI solution writes does not vary. A query, once written, runs the same way every time, and keeping it that way is a tale as old as git: put it in a file, version the file, and run the file. So Marmot makes the code the center of every analysis. The agent writes SQL to a file, the file is versioned, and the file is what runs.

The model’s job is to write a good query and explain it. The query’s job is to produce the number, the same way next quarter as today. The model can vary from run to run. The file it writes is deterministic: it stays fixed, and the team keeps that file.

We tested how far this goes. Over a weekend in October, we ran the same set of analysis questions through a stock Marmot agent and through one guided by a catalog of saved definitions and methods, across several models including smaller ones. With the catalog, the answers held across models, and the agent needed 60 to 70 percent fewer model calls to get there. The pinned method did the work the model used to do.

What Reproducible AI in Healthcare Requires

In Komodo Health’s Five Pillars of Trust framework, Reproducible means the same inputs and the same method return the same answer, and when that answer changes, the reason is on the record. Marmot makes this possible in three ways.

Repeatability. Every Marmot analysis is saved with the queries that ran, the codesets they referenced, and the parameters that shaped them: time windows, lookbacks, washouts, index rules. It’s also saved with the data refresh it ran against.

A brand team’s monthly tracker is the plain case. The same saved analysis runs in October against that same month’s data. If the count moves, that means the data moved, and the record shows that nothing else did.

Reusability. A definition a team has reviewed once becomes the starting point for the next analysis. In practice, this means the myasthenia gravis cohort that medical affairs signed off on in March is the same one that runs in the launch model in June.

One customer now shares saved Marmot reports with its field teams, who use them to make targeting decisions. The field doesn’t rebuild the analysis or ask for a refresh. They open the report, and it reruns against the current data with the method the analytics team already reviewed.

Iterability. Change one parameter, rerun, and compare. For example, a 12-month lookback against a six-month lookback. A brand-only basket against brand plus generic. Because everything else is pinned, the difference between the runs is the variable.

In a recent demo, an analyst took a finished Navigator analysis, added rheumatology as a specialty filter, and reran it. The second run cited the same sources and the same cohort, with one documented change. That’s the whole point: extending an analysis shouldn’t mean starting over or losing the trail.

pillars_of_ai_trust_blog

Why Healthcare Raises the Bar

Healthcare evidence can’t tolerate drift, for two reasons.

The first is that the work is meant to be rerun by someone else. An HEOR study, a payer dossier, and a regulatory submission all assume another analyst or  reviewer can take the method and get the same result. Regulators don’t accept an analysis a person can’t explain and rerun, and no AI solution changes that. The analyst has to own the method end-to-end, which is only possible when the method exists as something they can read, run, and change.

The second is that claims data refreshes and lags. Claims arrive weeks late and out of order, so a monthly brand tracker runs twelve times a year against twelve different snapshots. When March comes in below February, the team has to know whether that’s new claims landing or a changed definition. With the method pinned and the refresh recorded, only one of the two can have moved.

Questions to Ask a Healthcare AI Vendor About Reproducibility

Bring these to a demo:

  • If I ask the same question tomorrow, do I get the same answer? What makes that true?
  • Is the query that produced a number saved, versioned, and runnable without the chat that created it?
  • Does the system record which data refresh an analysis ran against?
  • Can I rerun last quarter’s analysis against this quarter’s data without rewriting it?
  • When two runs disagree, can the system show me whether the data, the definition, or a parameter changed?
  • Can I change one parameter and compare the result to the original run?

If the answer to the second question is “the model will regenerate it,” keep looking.

What We Have Not Solved Yet

The plan still varies before any code exists. The code is stable once written, but the steps the agent takes before it writes code can differ between sessions. Two analysts asking the same question can get two valid queries that make different reasonable choices. Saved definitions narrow this a lot, and narrowing it further is on Komodo’s roadmap.

One of our own product strategists put it well: for evidence work, they wanted the agent to check each step with them rather than make the calls on its own. That feedback is shaping what we build next. The honest status today is that the agent decides and makes defensible assumptions.

Analyses should run the same way everywhere in Marmot. The Navigator-to-Builder example I mentioned earlier was a user’s discovery, and it’s the kind we want to ideally catch ourselves. Checks that prove a query runs the same way in every Marmot surface are on the roadmap.

We record the data refresh but can’t replay it yet. We pin which refresh an analysis ran against, so you can see that the data moved. Rerunning today’s method against an earlier snapshot, to prove the data was the only thing that moved, is the next step on the roadmap.

Comparing runs is still manual. Today you rerun and look at both results. We’re planning and working towards a side-by-side view that shows what changed between two runs, by data, definition, or parameter.

Trust That Holds Up on the Second Run

Reproducibility turns a one-time answer into an analysis a team can rerun and hand to someone else, with every change on the record. Success looks like an analyst who reruns last year’s study in minutes, gets the same answer, and can show exactly what moved when the new data arrives.

Reproducible is one of the five pillars that work together. Grounded ties every answer to its source. Verifiable proves it’s correct. Explainable shows the path to it. Governed sets who can use it, how, and under which controls, and it’s the subject of the next post in this series, coming in December.

The same question should get the same answer. When it doesn’t, the reason should already be visible on the page.

To rerun one of your own analyses in Marmot and see what changes, request a demo.

About the Author

Kaushal Parikh is the VP of Product Management – AI Platform at Komodo Health, where he has worked since 2016. He has spent time across the Komodo organization, including commercial, data partnerships, and data product. Today, he leads the platform behind Komodo’s AI products, enabling insights to be democratized and every answer to be trustworthy and verifiable. Connect with Kaushal


Frequently Asked Questions

What Is Reproducible AI in Healthcare?

Reproducible AI in healthcare is AI whose analyses can be run again and return the same answer from the same inputs. Each analysis is saved as versioned queries, codesets, and parameters, along with the data refresh it ran against, so a rerun applies the same method and any change in the result traces to a change in the data or a recorded change in the method.

How Is Reproducible AI Different From Verifiable and Explainable AI?

Verifiable AI proves an answer is correct, and Explainable AI shows every reader the path to it. Reproducible AI keeps that path the same over time, so a rerun gives the same answer. In Komodo Health’s Five Pillars of Trust framework, all three work alongside Grounded and Governed, and none substitutes for the others.

Why Does Reproducibility Matter More in Healthcare Than in Other Industries?

Healthcare evidence is built to be rerun by someone else, such as a reviewer or a regulator. A brand tracker or an incidence study also runs repeatedly against claims data that refreshes and lags. Reproducibility is what lets a team separate a data update from a method change and defend the result either way.

Explore Related Posts