💻 computer science

Agentic AI Governance and Lifecycle Management in Healthcare

This paper proposes a Unified Agent Lifecycle Management (UALM) framework, featuring a five-layer control-plane architecture and a maturity model, to address the challenges of agent sprawl and accountability in healthcare by enabling audit-ready oversight and safe scaling of agentic AI workflows.

Original authors: Chandra Prakash, Mary Lind, Avneesh Sisodia

Published 2026-05-19

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Chandra Prakash, Mary Lind, Avneesh Sisodia

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 as a busy, high-stakes kitchen. In the past, the chefs (doctors and nurses) did all the cooking. Recently, they started hiring robots to help. At first, these robots were just simple tools, like a toaster that only made bread. But now, the hospital is buying "Agentic AI"—smart robots that can think, plan, and act on their own. They can check insurance, monitor patient vitals, and even suggest medication changes without being asked every single time.

The problem? The hospital is buying so many of these smart robots that they are getting out of control. This is called "Agent Sprawl."

It's like the kitchen suddenly having 50 different robots running around, but:

No one knows who owns which robot.
Two robots might try to do the same job at the same time, causing a mess.
A robot might keep working even after the chef fired it.
A robot might accidentally open the fridge to the wrong customer (leaking private patient data).

The authors of this paper, Chandra Prakash, Mary Lind, and Avneesh Sisodia, are worried that without a strict rulebook, these smart robots will cause chaos, safety risks, and privacy leaks. They propose a new system called UALM (Unified Agent Lifecycle Management) to fix this.

The Solution: A Five-Layer "Robot Control Tower"

The authors built a five-layer framework to manage these robots, similar to how an air traffic controller manages planes. Here is what each layer does, using simple analogies:

The ID Badge Layer (Identity & Registry):
- The Problem: Robots wandering around without names or owners.
- The Fix: Every robot gets a digital ID badge. The system knows exactly who built it, who is responsible for it, and what it is allowed to do. If a robot doesn't have a badge, it can't enter the kitchen.
The Referee Layer (Orchestration & Mediation):
- The Problem: Two robots arguing over who should do a task, or a robot trying to override a safety rule.
- The Fix: A "referee" robot stands between them. If the "Billing Robot" and the "Medication Robot" disagree, the referee decides based on the rules: Patient safety always wins over billing.
The Memory Vault Layer (Context & Memory):
- The Problem: A robot reading a patient's entire medical history when it only needs to know their blood type.
- The Fix: The robot's memory is locked down. It can only see the specific piece of information it needs for the task at hand (like a chef only seeing the recipe for the dish they are cooking, not the secrets of the whole restaurant).
The Security Guard Layer (Guardrails & Compliance):
- The Problem: A robot getting tricked by a hacker or trying to do something dangerous.
- The Fix: A security guard watches every move in real-time. If a robot tries to do something it shouldn't (like changing a drug dose without a human checking), the guard hits a "Kill Switch" and stops it immediately.
The Retirement Layer (Lifecycle & Decommissioning):
- The Problem: Robots that are outdated or broken but kept running because no one turned them off.
- The Fix: Every robot has an expiration date. When its job is done or it gets old, the system automatically turns it off, takes away its ID badge, and deletes its access keys so it can't cause trouble later.

How Did They Test This?

Since they couldn't wait for a real hospital to try this out (and it might be too risky to test on real patients), they built a computer simulation.

The Setup: They created three fake hospitals (a small one, a medium one, and a big one) and filled them with fake robots.
The Test: They ran the simulation four times for each hospital:
1. No Rules: Just letting the robots run wild.
2. Just a List: Keeping a simple list of who the robots are (but no rules on what they do).
3. Generic Rules: Using a standard AI safety checklist (like the NIST framework) that wasn't made specifically for robots.
4. The UALM System: Using their new five-layer control tower.

What Happened?

The results were clear. The UALM system was the clear winner.

Fewer Accidents: Compared to having no rules, the UALM system reduced accidents by about 60%.
Better Cleanup: When a robot needed to be retired, the UALM system turned it off in 3 days, whereas the other methods took 15 days or more.
Privacy Protection: The UALM system was much better at making sure robots only saw the private patient data they absolutely needed.
The "Maturity" Score: They created a "Growth Chart" for hospitals. Only the hospitals using the full UALM system were able to reach the "Managed" level of safety. The others got stuck at the bottom because they were missing key pieces (like the automatic shutdowns or the security guards).

The Catch (The "But...")

The paper also points out two important warnings:

You Can't "Set It and Forget It": The system only works if the hospital keeps paying attention to it. If the hospital starts strong but then stops caring (a "stalled" adoption), they lose about 80% of the benefits. It's like buying a high-tech security system but never checking if the batteries are working.
It Gets Heavy: As the hospital buys more and more robots, the "Control Tower" gets busier and harder to manage. It doesn't get harder in a straight line; it gets much harder very quickly. If a hospital has too many robots, they might need to split the control tower into smaller teams.

The Bottom Line

The paper argues that we can't just let these smart, autonomous robots run wild in hospitals. We need a specific, five-layer management system to keep them safe, accountable, and private.

Their simulation shows that if hospitals use this UALM framework, they can have the benefits of smart robots without the chaos. However, it requires a serious, ongoing commitment from hospital leaders to keep the system running. It's not a magic button; it's a new way of running the kitchen.

Technical Summary: Agentic AI Governance and Lifecycle Management in Healthcare

Problem Statement
Healthcare organizations are transitioning from generative AI pilots to autonomous, goal-directed "Agentic AI" systems capable of planning, tool use, and multi-step execution. While these systems offer proactive care and workflow automation, their uncoordinated proliferation leads to "agent sprawl." This phenomenon results in duplicated agents, unclear accountability, inconsistent controls, and persistent tool permissions that extend beyond original use cases. Existing governance frameworks, such as the NIST AI Risk Management Framework (RMF) and the EU AI Act, emphasize lifecycle risk management but lack specific operational guidance for the day-to-day management of agent fleets. They fail to address the unique challenges of non-human identities, inter-agent conflicts, and the need for runtime policy enforcement in environments handling Protected Health Information (PHI). Consequently, healthcare leaders face safety risks, compliance gaps (specifically regarding HIPAA access and audit controls), and inefficiencies without a standardized control plane to govern agent lifecycles.

Methodology
To evaluate the operational viability of a proposed governance architecture, the authors conducted a Monte Carlo simulation. The study modeled agent fleet operations over a six-month pilot phase across three synthetic healthcare organization profiles: a small community hospital (150 beds), a regional system (400 beds), and an academic medical center (800 beds).

The simulation compared four distinct governance conditions:

No Governance: A baseline where agents operate without centralized oversight.
Registry-Only: A condition implementing only a centralized agent inventory (Layer 1) with identity management.
NIST RMF-Lite: The application of generic AI risk management principles without agent-specific lifecycle controls.
UALM (Unified Agent Lifecycle Management): The full implementation of the proposed five-layer framework.

The simulation injected seven stochastic event types monthly (e.g., agent drift, orphan events, PHI near-misses, prompt injection) with probabilities scaled by agent criticality and PHI exposure. Performance was measured against seven Key Performance Indicators (KPIs), including credential revocation time, tool-call logging rates, and incident rates. Statistical analysis utilized Mann-Whitney U tests, Cohen's d effect sizes, and 95% confidence intervals, with sensitivity analyses performed on event probabilities, growth rates, and governance adoption curves.

Key Contributions
The paper introduces three primary contributions:

The Unified Agent Lifecycle Management (UALM) Framework: A five-layer control-plane architecture designed to govern agent fleets:
- Layer 1 (Identity & Persona Registry): Establishes a single system of record for Non-Human Identities (NHI), defining ownership, scope of practice, and liability.
- Layer 2 (Orchestration & Mediation): Manages inter-agent communication, resolves conflicts based on policy precedence (prioritizing clinical outcomes), and enforces goal prioritization.
- Layer 3 (Context & Memory): Ensures PHI compliance through segmentation, vector-store access controls, and retention-bound longitudinal context.
- Layer 4 (Guardrail & Compliance): Provides real-time monitoring, "Governance-as-Code" enforcement, and kill-switch protocols for unauthorized actions.
- Layer 5 (Lifecycle & Decommissioning): Manages provisioning, change control, and automated retirement, including the revocation of NHI tokens.
A Measurable Maturity Model: A companion model defining four maturity levels (Ad-hoc, Managed, Integrated, Optimized) with strict, KPI-linked thresholds. Advancement requires all seven KPIs to meet the target simultaneously, ensuring objective assessment.
Simulation-Based Evaluation: An empirical comparison demonstrating the quantitative impact of UALM against current governance standards under transparent, modeled assumptions.

Results
The simulation results indicate that UALM consistently outperforms alternative governance conditions across all organization sizes and KPIs:

Incident Reduction: UALM reduced agent-related incident rates by 56–63% compared to the "No Governance" baseline.
Comparison with NIST RMF-Lite: Against the most relevant comparator, UALM demonstrated large effect sizes (Cohen's d ranging from 0.99 to 6.06). Notable improvements included an 80% reduction in credential revocation time (d = 6.06), a 57% increase in tool-call logging (d = 2.95), and a 77% improvement in PHI minimization (d = 2.83).
Maturity Attainment: Only UALM-governed organizations achieved Level 2 (Managed) maturity in the simulation (18–21% of runs). Neither Registry-Only nor NIST RMF-Lite conditions reached Level 2, as they structurally failed specific KPIs such as credential revocation speed and PHI minimization.
Robustness and Sensitivity: UALM's advantages remained robust under worst-case parameter variations (e.g., high event probabilities and rapid growth). However, the study found that the benefits are highly dependent on sustained organizational commitment; a "stalled" governance ramp-up erased approximately 80% of the potential benefits.
Limitations Identified: The analysis highlighted that centralization overhead scales non-linearly with fleet size (approx. $O(n^{1.3})$ ) and that intermittent control-plane outages can increase incident rates by roughly 2.8 times.

Significance and Claims
The paper claims that UALM addresses critical gaps in existing AI governance by translating high-level risk principles into an enforceable, runtime control plane specifically for agentic systems. The authors assert that the framework provides agent-specific governance advantages that generic AI risk management (like NIST RMF) cannot offer, particularly in automating lifecycle management, enforcing policy-as-code, and protecting PHI.

The significance of the work lies in its provision of an implementable pattern for "audit-ready oversight" that preserves local innovation while enabling safer scaling. The authors position the risk of agent sprawl not merely as a technical scaling issue, but as an ethical governance challenge where unmanaged autonomy threatens safety, accountability, and trust. By operationalizing UALM, healthcare organizations can transition from fragmented, domain-specific deployments to a disciplined, managed agent fleet. The study concludes that while the framework introduces centralization overhead, the trade-off is necessary to ensure that autonomous agent adoption remains auditable and safe at an enterprise scale.