🤖 AI

Healthcare Mechanisms from Policy-as-Code Search under Strategic Provider Response

This paper reframes healthcare mechanism design as a program synthesis problem using an LLM-guided evolutionary search and a multi-agent simulator (Medi-Sim) to dynamically model strategic provider responses, successfully synthesizing an inspectable rule-based mechanism that eliminates up-coding and reduces patient rejection while maintaining financial viability.

Original authors: Zihan Wang, Xiang Xu, Hongyuan Zha, Wenhao Li

Published 2026-06-01

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Zihan Wang, Xiang Xu, Hongyuan Zha, Wenhao Li

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a hospital not just as a place where sick people get better, but as a giant, complex game of "Follow the Rules."

In this game, there are two main players:

The Hospital Administrator: They set the rules of the game (how much doctors get paid, how they are judged, how many beds are available).
The Doctors and Staff (Providers): They play the game. But they aren't passive robots; they are smart, strategic players who want to win (make money, keep their jobs, avoid getting in trouble).

The paper argues that most current computer models for healthcare are broken because they treat the doctors like passive NPCs (non-player characters) in a video game who just do what they are told. In reality, doctors are strategic players. If you change the rules, they don't just follow them; they find loopholes, shortcuts, or new ways to play that might hurt the patient even if they help the doctor.

Here is a simple breakdown of what the paper does and finds:

1. The Problem: "Whac-A-Mole" with Rules

The authors call this "Pressure Migration."

Imagine you are playing Whac-A-Mole. You hit a mole (a bad behavior) with a hammer (a new rule), and it goes down. But in healthcare, the mole doesn't disappear; it just pops up in a different hole.

Example: If you make it very hard for doctors to "up-code" (fake a patient's illness to get more money), they might stop faking the illness but start cherry-picking (only accepting easy, healthy patients and rejecting the sick ones) or delaying care.
The Mistake: Old computer models only check if the "fake illness" stopped. They miss the fact that the "rejecting sick patients" problem got worse. They think the rule worked, but it just moved the problem.

2. The Solution: A "Digital Twin" Hospital

The authors built a new computer simulator called Medi-Sim. Think of it as a flight simulator for hospital managers.

The Twist: In this simulator, the "pilots" (doctors) are smart. They react to the rules.
The Rules are Code: Instead of writing rules in plain English (which can be vague), the administrators write them as computer code. This is called "Policy-as-Code."
- Why? Because code is precise. You can look at every single line and see exactly what the rule does. This is crucial because real-world healthcare rules must be auditable (you must be able to prove exactly why a decision was made).
The Loop: The simulator runs a full cycle:
1. Identify: Patients arrive.
2. Produce: Doctors treat them (or don't).
3. Settle: The hospital gets paid and gets a score.
- The doctors' reactions to the payment and score feed back into the next round.

3. The Discovery: The "Phase Diagram"

The researchers ran thousands of simulations, changing the "incentives" (how much money vs. how much quality doctors care about). They found that healthcare failures aren't random; they happen in specific "zones" or regimes:

The Profit Zone: If you pay doctors mostly based on volume, they start faking illnesses (up-coding) and avoiding sick patients.
The Quality Zone: If you pay doctors only for "looking good" on paper, they might work too hard on easy cases (gold-plating) or ignore the budget, leading to the hospital going broke.
The "Balanced" Trap: This is the most dangerous zone. When you try to balance profit and quality, the doctors might look like they are doing great. But actually, they are just hiding the problem. They might stop faking illnesses, but they start delaying care for complex patients or gaming the system in subtle ways that make the "quality score" look good while the actual health outcomes get worse.

4. The Magic Tool: AI as a "Code Editor"

The authors used a Large Language Model (LLM)—a type of AI—not to write the rules from scratch, but to edit them.

They gave the AI a library of existing rules (some good, some bad).
The AI tried to "evolve" these rules by making small code changes, like a programmer debugging a script.
The Goal: Find a set of rules that keeps the hospital profitable without forcing doctors to cheat.

The Result:
The AI found a "mixed" set of rules that worked like a charm in the simulation:

It eliminated the fake illness coding completely.
It cut in half the number of patients being rejected.
It kept the hospital's profits almost as high as the "greedy" profit-focused rules.

5. The Big Lesson: Don't Just Measure the Score

The paper concludes that if you want to fix healthcare, you can't just look at the final score (like "Did we make money?" or "Did we hit the target?"). You have to look at how the players got there.

The Analogy: If a student gets an 'A' on a test, you need to know if they studied hard or if they cheated. In healthcare, if a hospital gets a high score, you need to know if they treated patients well or if they just hid the sick ones.
The Tool: The new simulator (Medi-Sim) allows us to test rules before we use them in the real world, watching to see if the doctors find a new loophole (pressure migration) before we actually implement the policy.

In short: The paper built a "stress-test" video game for hospital rules. It showed that when you change the rules, doctors find new ways to game the system. But by using AI to carefully edit the code of those rules, we can find a "sweet spot" where the hospital makes money, the doctors are happy, and the patients actually get better care—without the doctors having to cheat.

Technical Summary: Healthcare Mechanisms from Policy-as-Code Search under Strategic Provider Response

1. Problem Formulation

The paper addresses a critical gap in evaluating healthcare mechanisms: existing benchmarks treat provider behavior as fixed or exogenous, failing to account for strategic provider response. In reality, hospital mechanisms (e.g., payment rules, audits, quality bonuses) induce strategic behaviors from providers that can distort outcomes. This phenomenon, termed pressure migration, occurs when closing one distortion channel (e.g., up-coding) causes the same incentive pressure to resurface in an adjacent channel (e.g., patient selection or strategic delay).

The authors model the hospital as a finite-horizon stochastic Stackelberg game:

Leader: The hospital administrator commits to a mechanism (policy) $u_t$ at each time step.
Follower: A population of provider teams responds strategically based on a bounded-rationality response class $\Pi_P$ .
Objective: The administrator seeks to optimize a social objective (welfare, profit, or mixed) while ensuring the induced provider behavior remains acceptable across multiple diagnostic channels.

The core challenge is that standard machine learning approaches (e.g., black-box neural controllers) fail to meet the auditability requirements of regulated healthcare deployment, while existing economic models often lack the granularity to simulate complex, multi-channel strategic responses in a closed loop.

2. Methodology: Medi-Sim and Policy-as-Code

The authors introduce Medi-Sim, a closed-loop simulator that integrates mechanism design with strategic response, and reframe the design problem as program synthesis over a typed Domain Specific Language (DSL).

The Medi-Sim Environment (Identify–Produce–Settle)

Medi-Sim operates on an Identify–Produce–Settle (IPS) loop:

Identify: Patients arrive with true clinical complexity ( $CMI^\star$ ). Hospital coders map these to reported billing groups ( $\hat{g}$ ), creating a coding wedge between true complexity and reimbursement.
Produce: Provider teams make decisions constrained by capacity and fatigue. Their actions decompose into five strategic distortion channels:
- Coding: Up-coding to increase reimbursement.
- Selection: Cherry-picking low-complexity patients or rejecting high-complexity ones.
- Delay: Strategically deferring high-cost cases.
- Effort: Adjusting treatment intensity (gold-plating vs. skimping).
- Triage: Resource allocation and accept/reject decisions.
Settle: Reimbursement is calculated based on reported groups. Performance is measured via a weighted KPI (health, waiting, rejection, cost), which creates a measurement wedge between true clinical value and the proxy metric used for bonuses.

Policy-as-Code Search

To satisfy regulatory constraints, the policy class $\Pi_A$ is restricted to typed, inspectable rule programs rather than neural networks.

DSL: Policies are written as executable expressions over a fixed set of administrative levers (incentive coefficients, audit intensity, bonus pools, KPI weights).
Search Algorithm: The authors employ AlphaEvolve-style evolutionary code search guided by Large Language Models (LLMs). The LLM acts as a code-editing operator, performing semantic mutations on the rule programs.
Fitness Function: The search optimizes a safety-penalized objective that includes the social return, a penalty for safety/distortion violations (e.g., up-coding, unsafe waiting), and a variance regularizer.

3. Key Contributions

LLM-Program-Synthesis Testbed: The paper establishes a framework for high-stakes mechanism design where the LLM edits inspectable code under safety constraints, excluding black-box controllers.
Medi-Sim Benchmark: A closed-loop simulator that keeps administrator rules, five strategic provider channels, and realized outcomes in the same rollout, enabling the detection of channel-level distortions.
Pressure Migration as a Benchmark Phenomenon: The work demonstrates that classical healthcare failures (up-coding, cream-skimming) occupy adjacent regimes in a single incentive phase diagram. It shows that LLM-guided code search can refine policies to eliminate specific distortions without triggering pressure migration to other channels.

4. Experimental Results

The experiments follow a three-layer validation-to-discovery logic:

L1: Incentive Phase Diagram

An 11x11 sweep of profit sensitivity ( $\alpha$ ) and quality sensitivity ( $\beta$ ) reveals four distinct regimes:

Profit-driven: High up-coding and selection bias (cherry-picking).
Quality-driven: High effort but financial insolvency.
Low-incentive: Access rationing.
Balanced Interior: A hidden failure mode where visible metrics (up-coding, rejection) improve, but pressure migrates to strategic delay and KPI targeting, causing the measured KPI to become negatively correlated with true health (Goodhart's Law).

L2: Administrative Lever Sweeps

The study traces how administrative controls shift pressure across channels:

Audits: Increasing audit probability successfully suppresses up-coding but significantly increases cherry-picking (selection distortion), demonstrating channel substitution.
Bonus Pools: Larger bonuses amplify the misalignment between the KPI proxy and true health, worsening Goodhart-style drift.
Flexible Capacity: Under KPI steering, increasing flexible capacity actually increases waiting times because capacity is allocated to teams chasing bonus scores rather than those with the longest queues.

L3: Policy-as-Code Search

The search layer tests the ability to synthesize mechanisms that balance objectives:

Profit Objective: Search refines the baseline but amplifies up-coding (0.758 $\to$ 0.807) to maximize funds.
Welfare Objective: Search improves access and reduces effort costs while maintaining zero up-coding.
Mixed Objective (Key Result): The search synthesizes a policy that:
- Eliminates up-coding (rate drops to 0.000).
- Halves rejection rates compared to the profit baseline.
- Retains most of the profit-oriented baseline's funds.
- Mechanism: The searched policy lowers local bonus pressure and introduces a hard-threshold penalty in the coding score that strictly forbids coding deviations above a specific gap, effectively closing the coding channel without increasing rejection.

5. Significance and Claims

The paper claims that Medi-Sim provides a necessary diagnostic environment for healthcare policy ML, moving beyond static benchmarks to evaluate mechanisms under endogenous strategic response.

Auditability: By restricting policies to typed code, the system ensures that mechanisms remain human-readable and auditable line-by-line, a prerequisite for regulated deployment.
Channel Substitution: The work highlights that single-metric optimization is insufficient; closing one distortion channel often opens another. Effective mechanism design requires monitoring the entire response vector.
Feasibility of Search: The authors present the LLM-guided search as a feasibility demonstration of program synthesis over mechanism-as-code. They modestly note that the success of the mixed-objective policy relies heavily on a diverse warm-start library; search alone, starting from a neutral prior, failed to recover the optimal family.

The paper concludes that provider-side strategic response should be a standard benchmark target for ML in healthcare policy, and that policy-as-code search offers a viable path to designing robust, inspectable, and multi-objective healthcare mechanisms.