How to orchestrate a healthcare enterprise with agentic AI
Traditional information systems are decoupled in independent silos, requiring human triage. An agentic AI orchestrator bridges these gaps at machine speed.
In previous articles, we explored how a decentralized data mesh architecture, powered by domain-driven ownership and micro-Medallion pipelines, liberates healthcare data from monolithic silos.
While FHIR is a brilliant edge protocol for clinical data exchange, it only represents a slice of the entire enterprise. Up to this point, the industry’s primary goal has been analytical — getting clean, governed data into dashboards so humans can make better decisions.
But dashboards are inherently passive, and the pace of modern healthcare operations is not. The next frontier of the healthcare enterprise is the transition from analytical data mesh to active, operational orchestration. This is the promise of agentic AI; these systems do not just display data, but are granted the secure credentials, context and reasoning capability to make decisions at key inflection points and execute workflows across disparate transactional systems.
For the healthcare chief digital or data officer, the strategic question is no longer, "How do we report on what happened?" It is, "How do we build the architecture that enables AI to safely orchestrate what happens next?"
The anatomy of an operational crisis
To understand why traditional IT architectures fail at active orchestration, consider a standard, high-stakes operational challenge in the emergency department — a clinical predictive model, reading real-time telemetry from an incoming ambulance via FHIR, flags a high-probability acute cardiac event.
To save this patient’s life, simply alert-fatiguing a clinician's screen is not enough. The enterprise must immediately orchestrate a multi-system logistical response, including the following.
Clinical/EHR (for example, Epic or Cerner). Pre-register the patient, route them to an available cardiac catheterization lab and update the EHR.
Staffing/HR (for example, Workday or legacy SQL). Verify that an interventional cardiologist and a specialized nursing team are currently on-duty, alert them, and dynamically adjust shift schedules if necessary.
Supply chain/ERP (for example, SAP or Oracle). Ensure the correct cardiac prep kits and medical devices are reserved and routed to the correct room.
In a traditional setup, these systems are entirely decoupled. They operate in independent silos, governed by strict licensing and are completely blind to each other. Resolving this requires manual phone calls, page alerts and human triage.
An agentic AI orchestrator bridges these gaps at machine speed. It acts as an active "system of engagement" sitting above your legacy "systems of record."
De-fogging the agentic stack
It is easy to dismiss agentic AI as vendor "wishful thinking." It is highly unrealistic to expect legacy, licensed transaction systems in healthcare to disappear or adopt a unified modern database layer overnight. The transactional footprint of the EHR, ERP and HR platforms is set in concrete.
The role of agentic AI is not to replace these systems, but to interact with them dynamically. To do this, AI developers and data architects equip agents with three specific translation pathways.
Semantic virtualization (the reading layer). Autonomous agents cannot make sound decisions if they are hallucinating metrics or querying outdated databases. Instead of building rigid, expensive ETL pipelines to centralize all operational data, architects use a centralized semantic layer and catalog. When the agent needs to know, "Who is the on-call interventional cardiologist right now?" it uses natural language reasoning to call a secure, read-only API that queries the underlying scheduling database in real time, returning trusted, governed context.
RPA as an agentic "hand" (the legacy writing layer). Many legacy healthcare systems have no modern APIs whatsoever. To enable an agent to actually act — for example, by reserving equipment in an older inventory application — developers wrap legacy interfaces in robotic process automation (RPA). Agentic AI makes the cognitive decision ("Reserve Kit X"), formats the payload and hands it to an RPA bot. The bot logs into the legacy user interface, clicks the required buttons, executes the transaction and reports its actions back to the agent.
Domain-level "sandboxing" (the safety mechanism). Autonomous software can't be allowed to test operational hypotheses directly inside live production clinical databases. Doing that risks slowing down core systems, locking tables or, worse, executing unauthorized actions in the real world. At the same time, we must fiercely avoid the anti-pattern of dumping all transactional data into a massive centralized enterprise data lake just to run these tests.
To solve this safely, we leverage the data mesh principle of domain-owned data products. Each business domain (such as care coordination, logistics or staffing) maintains its own localized, read-optimized operational data store using modern, lightweight, open table formats like Delta Lake or Apache Iceberg.
When an agent needs to simulate a scenario, such as re-allocating staff and rooms for an incoming cardiac patient, it doesn't query the live EHR. Instead, it requests a localized, zero-copy branch of only the relevant domain's data product.
Agentic AI orchestration in a decentralized enterprise with legacy systems
Demystifying the 'zero-copy branch'
To understand why this is an elegant architectural breakthrough, consider how data is traditionally copied.
If you want to write notes or make changes in a 1,000-page book without ruining the original, the traditional approach is to photocopy all 1,000 pages to create a physical second book. In enterprise healthcare, physically copying terabytes of clinical data is slow, incredibly expensive in cloud compute and storage, and introduces massive compliance and security risks.
A zero-copy branch completely bypasses this physical bottleneck by separating data from metadata (the pointers that show where the data physically lives on disk). Here are the capabilities of such an approach.
Instantaneous creation. When the agent requests a branch, the underlying domain database doesn't copy any actual patient records. Instead, it instantly duplicates only the metadata, essentially copying just the table of contents. Because this metadata file is tiny, the agent's sandbox is created in milliseconds.
Shared, read-only foundation. Both the live domain database and the agent’s new sandbox read from the exact same physical storage files on disk. There is zero storage footprint duplication.
Isolated writes via "copy-on-write." The magic happens when the agent begins running its simulations (for example, "What happens if I change the status of operating room 3 to 'Reserved' and assign Dr. Smith?"). These changes are not written to the production files. Instead, the storage layer writes only those newly modified records to a tiny, isolated delta file dedicated exclusively to the agent's branch.
Seamless virtualization. The agent interacts with what looks and acts like a fully populated, real-time database. It can run its algorithms, test variables and query states, completely unaware that it is operating in a virtualized layer.
The lifecycle of an agentic decision
By utilizing this domain-level metadata trick, the lifecycle of an autonomous operational decision becomes remarkably clean.
The simulation. The agent runs its multi-variable simulation inside the isolated, zero-copy branch.
The evaluation. The agent evaluates the outcome against the domain's business rules.
Execution or discard. If the test succeeds, the agent submits the finalized command back to the domain's primary transactional system (the system of record) via a secure, governed API, RPA or other legacy-friendly methods. If the test fails, the agent simply deletes its branch. The metadata pointers are wiped out, the isolated delta writes are discarded, and the sandbox vanishes in milliseconds.
The entire process occurs at the domain level. By leveraging zero-copy branching within local domain data products, agents are given the freedom to safely experiment, fail and self-correct at machine speed, all while maintaining strict boundary controls, protecting clinical systems and refusing to feed the gravity of a centralized data monolith.
Governance is the engine, not the brake
In the dashboard era, data governance was a static, once-per-project security review. In the agentic era, where software is dynamically calling APIs, writing data, and spinning up parallel instances, every action is a governance event.
Because of this, there must be a transition from process-level governance to platform-level governance. Autonomous agents must be treated with the same rigorous lifecycle management that is applied to data products.
The paved path. After an agentic integration pattern is validated against HIPAA, security and risk frameworks, that architecture must be templatized. Subsequent use cases can follow this paved path, dropping the marginal cost of governance to near zero.
The human-in-the-loop gate. Autonomy is earned, not given. In early deployments, the agent synthesizes the data, runs the simulations across the ERP and EHR, and presents a comprehensive action plan to an emergency department charge nurse or operational director. The human retains final judgment, clicking "approve" to execute. Only when the system achieves near-perfect trust metrics is the manual gate removed for low-risk, highly repeatable workflows.
The transition to agentic AI is the ultimate validation of the data mesh strategy for which we have advocated throughout this series. Without a strong foundation of clean, semantically consistent and governed domain data products, an autonomous agent is simply an engine for making wrong decisions at machine speed.
By building a robust data foundation and coupling it with intelligent orchestration tools, healthcare leaders can finally move past passive reporting. We can build an enterprise that doesn't just show us what is broken, but actively coordinates the resources, people and systems to fix it in real time.
Aaron Seib, PMP, CPMAI, FACHDM, CDMP-practitioner, is a 30-year veteran of the health IT industry.