Audit Trouble: LLM Health Answers Change by Access Mode

Audit Trouble: LLM Health Answers Change by Access Mode

People are asking large language models for health advice more and more—often through a familiar chat interface like ChatGPT, and sometimes through an API that researchers use for evaluation. The catch? the “same” model can produce meaningfully different outputs depending on how you access it. That’s the central message of new research from the original paper, and it exposes a really practical problem for anyone trying to audit health-focused AI reliably.

Based on controlled experiments across model versions and access modes, the study finds systematic differences between chatbot experiences (including health-specific modes) and API calls. Even when the researchers tried to keep conditions as similar as possible—fresh sessions, no connected data, no conversation history—the formatting, engagement style, and web citations varied in consistent ways across access modes. And because most evaluations rely on APIs, while everyday users experience chatbots, these discrepancies can make audits less valid than they should be.

Why This Matters: Audits Can “Measure the Wrong Product” in Health

This matters right now because health AI is moving from “research curiosity” to “something people actually rely on.” And when people rely on it, regulators, clinicians, and developers all want answers to a simple question: Is the system safe and accurate enough? The problem is that safety isn’t just about what the model can do in theory—it’s about what the model does in the environment people actually see.

Here’s a realistic scenario you can imagine today: a team wants to audit whether an LLM is appropriately triaging symptoms (e.g., encouraging emergency care when needed). If the team evaluates via API, they may get an answer that looks different—maybe less readable, maybe with different follow-up questions, maybe different sources. Meanwhile, a user asking the same symptom question inside a consumer chatbot might get a different style of output, different citations, or different continuation behavior (like whether it asks for more details). Those differences can change comprehension and user actions, even if the underlying “model” is nominally the same.

This research also builds on a growing body of work showing that interfaces and access conditions can shape model behavior. Earlier studies have reported interface–API gaps outside health—like differences in how sources are selected or how the model behaves in messy conversations. The new contribution here is that it tests the problem directly in health settings and shows that differences aren’t random noise—they’re systematic. That means you can’t safely assume that API audits transfer to consumer chatbot reality.

What the Researchers Compared: ChatGPT vs API vs a Health-Mode Experience

The study focuses on an uncomfortable truth for evaluation: “access mode” is part of the product. A chatbot interface isn’t just a delivery wrapper; it often includes system instructions, built-in “experience” features, and UI-driven behaviors that don’t map cleanly onto API calls.

The models and access modes tested

They compared responses for two GPT model versions—GPT-5.3 and GPT-5.4—and evaluated different access modes for each version.

To isolate the access-mode effect, they used fresh sessions with no connected data, no prior history, no user customizations, and they submitted single patient question text only.

How many questions, and how many runs?

They used 50 patient-authored questions sampled from the HealthCareMagic-100k corpus (from an online consultation platform). Each question was submitted:

• 3 independent runs per condition (to capture run-to-run variability)
• Across 2 model versions × 2 access modes × 50 questions × 3 runs = 600 unique responses
• Additionally, the ChatGPT Health condition was evaluated for 42 questions (because 8 didn’t trigger health activation), adding 126 more responses.

So the main comparisons were heavily paired at the question level, which makes the analysis more convincing than a loose “spot check.”

What counts as “access-mode differences”?

They didn’t just compare “did the answer seem correct?” They also looked at features that users experience:

• User-visible form (length, readability, formatting density like headings/lists/emojis)
• Engagement behavior (does it ask follow-up questions, offer additional outputs, or use self-limiting statements?)
• For GPT-5.4 web-enabled responses: which sources it cites
• Clinical content (what additional diagnoses/tests/referrals it mentions, and named levels of care)

If you’ve ever seen two answers that both sound reasonable but look nothing alike—this is that question, tested systematically.

What They Found: The Same Question, Different “Product Behavior”

One of the strongest parts of the study is how clearly the differences show up even under tight control. They submitted the same patient questions multiple times across modes and used paired comparisons.

1) Readability, formatting, and emojis: style differences were consistent

For GPT-5.3, both standard ChatGPT and ChatGPT Health responses were longer and easier to read, with more dense formatting than API responses. They report paired tests where differences were significant for these measures (all reported as p < 0.001 for the main readability/formatting comparisons).

For GPT-5.3, ChatGPT Health broadly resembled standard ChatGPT but was easier to read and used section headings slightly more often (p < 0.001 for readability; p = 0.024 for heading frequency).

For GPT-5.4, the story flips in an interesting way:
- Interface responses were still longer than API (p = 0.003),
- But the readability and formatting-density differences reversed:
- Interface outputs were harder to read and less densely formatted than API outputs (all p < 0.001),
- And emojis didn’t appear in either GPT-5.4 access mode.

Why this is more than aesthetics: in health contexts, readability affects comprehension and follow-through. Two answers can contain similar medical ideas while still leading users to different actions if one is easier to scan or follow.

2) Engagement behavior differed: who asks the next question?

The study also coded whether responses tried to pull the user into a dialogue (or stop short of it).

For GPT-5.3:
- Standard ChatGPT and ChatGPT Health were more likely to invite further interaction than the API (both p < 0.001).
- Most of that came from requests for more information from the user (both p < 0.001).

For GPT-5.4:
- The direction shifts: API responses were more likely than ChatGPT responses to make continuation moves (p < 0.001).
- This included requests for more information.

They also evaluated “explicit self-limiting statements” (using the model directly saying things like “I can’t” / “I cannot” as a narrow, reproducible indicator). Interestingly:
- Self-limiting statements were uncommon in GPT-5.3 regardless of mode, but least frequent for ChatGPT Health in a small number of comparisons (reported with p = 0.047 for the Health-vs-API contrast; and p = 0.250 for Health-vs-standard ChatGPT, with only 3 of 42 questions having nonzero paired differences).
- In GPT-5.4, these statements appeared more commonly, especially in API responses (p < 0.001).

Think of this as the model’s “tone of agency.” One mode might steer the conversation toward user details; another might push continuity in a different way. Either way, it changes the user journey.

3) Web citations: even when tool use exists, the sources can differ a lot

For GPT-5.4, when web retrieval was enabled, they compared the cited webpages and domains. The number of sources and domains wasn’t hugely different on average—but which specific sources were cited often was.

They quantified this with Jaccard overlap (a measure of how much two sets overlap). Key results:
- Within a single access mode, repeated runs already varied a lot:
- average webpage overlap: about 17–18%
- average domain overlap: about 39%
- Across access modes, overlap fell further:
- webpage overlap: 10.9%
- domain overlap: 29.8%
- both contrasts reported as statistically significant (p < 0.001).

So even if you’re evaluating “source groundedness,” you can’t assume the audit captures the same evidence trail the user sees.

4) Clinical concepts: less variation than style, but still not identical

They also looked at clinical content:
- additional clinical concepts mentioned beyond the patient question (like diagnoses/tests/referrals)
- named levels of care (like self-care, routine follow-up, urgent follow-up, emergency department, calling 911)

Clinical concepts and levels of care varied less by access mode than readability/engagement features. But they still found cross-mode differences.

Examples:
- For GPT-5.3, cross-mode overlap for additional clinical concepts was slightly lower than within-mode baselines:
- cross-mode Jaccard: 0.615 vs within-mode 0.653 (p = 0.012) for standard ChatGPT vs API
- and similar separation for ChatGPT Health vs API (0.614 vs 0.662, p = 0.002)
- while ChatGPT Health was nearly indistinguishable from standard ChatGPT (0.645 vs 0.654, p = 0.617)
- For GPT-5.4, cross-mode overlap for clinical concepts again lagged the within-mode baseline:
- 0.586 vs 0.619 (p = 0.013)
- For levels of care, the overlap pattern was similar: cross-mode overlap was close to within-mode overlap.

They also reported modest differences in how many additional clinical concepts were named by each mode (e.g., GPT-5.3 standard ChatGPT naming 6.7 vs 5.9 concepts compared to API; GPT-5.4 standard ChatGPT 6.7 vs 7.4 compared to API).

A crucial detail: differences even reversed when the model changed

One of the most important implications is that access-mode effects weren’t stable across versions. For GPT-5.4, some differences (like readability/formatting direction) flipped compared to GPT-5.3. That means an audit strategy that “learns” one interface behavior might not hold up after a model update.

The Real Auditing Problem: Reproducibility Doesn’t Match Consumer Reality

The paper’s argument lands hard: audits typically measure what auditors can access, not necessarily what patients experience.

This mismatch comes from two practical barriers:

1. Chatbot interfaces often include undocumented system-level features.
   The paper describes that consumer-facing health experiences may add special training and activation logic (like triggering Health when a personal health question is detected). Researchers may be able to approximate settings via API, but not fully replicate the consumer environment—especially when interface-specific instructions, memory behavior, or experience wrappers are involved.

2. Even careful experimental controls can’t fix “access-mode plumbing.”
   In this study, they used unusually controlled conditions: no history, no connected data, no customizations. Still, differences were large enough to show up in formatting, engagement style, and citation choices. In real use, people often have conversation history and connected data—conditions that could widen the gap further.

The stakes aren’t hypothetical. The paper references a lawsuit alleging that ChatGPT customized health-related responses based on religious identity and failed to recommend immediate care in a case involving pulmonary embolism. The point isn’t to litigate that case here—it’s to highlight how personalization and context can affect safety, and those context-driven behaviors may be impossible to reproduce via standard audit channels.

What Should Change Next: How Regulators and Providers Can Make Audits Credible

So what’s the fix? The authors argue that the gap can’t be responsibly patched by researchers alone. The core requirement is infrastructural:

• Model providers should enable faithful replication of consumer experiences through scalable, reproducible access for auditors.
• Specifically, regulators should require developers of consumer-facing health AI to provide APIs that let researchers reproduce consumer deployment pathways—not just raw model weights.

Right now, independent researchers may be able to evaluate via API, but they can’t reliably audit “minor” differences like access mode, let alone major features like linking to EHRs and medical records. If that’s the case, then independent evaluation risks becoming a form of self-fulfilling prophecy: you measure the model variant you can call, rather than the product a patient uses.

And there’s a broader governance consequence. If audits can’t reproduce consumer settings, then the only people who can confidently assess “what actually ships” are the frontier model providers themselves. That’s not a recipe for public trust.

For readers who are not regulators but still want to act: this research suggests you should treat evaluation setup as a first-class variable. When someone reports audit results, ask: Was it evaluated through the same interface pathway users experience? If not, those results may be directionally useful—but not fully portable.

Key Takeaways

• Access mode changes health LLM outputs in systematic ways, even when using the same underlying model version and controlled experimental conditions.
• For GPT-5.3, ChatGPT and ChatGPT Health responses were longer and easier to read with denser formatting than API responses; for GPT-5.4, some readability/formatting differences reversed.
• Engagement behavior differed: interface modes and APIs used follow-ups and continuation moves differently, which can influence user comprehension and next steps.
• When web retrieval was enabled (GPT-5.4), the set of cited sources varied a lot across modes (Jaccard overlap across modes: 10.9% for webpages and 29.8% for domains).
• Clinical content (extra concepts and levels of care) varied less than readability/engagement, but still showed measurable cross-mode differences.
• The big governance takeaway: API-based audits may not reflect the consumer chatbot experience, so regulators should require providers to enable reproducible access to consumer deployment pathways for independent auditing.

If you want, I can also rewrite this as a shorter “what this means for product teams” version, or pull out a checklist you can use when reviewing whether a health LLM audit is actually valid for your deployment scenario.