🤖 AI

Three Generations of Healthcare IT: From the Digital Record to the Computable Care Process

This paper proposes a new framework for organizing Healthcare IT by the unit of information it makes computable, introducing a third layer focused on "patient-specific clinical intent" and formalizing the "Actionable Clinical Record" (ACR) as its atomic object to bridge the gap between natural communication and structured, executable care processes.

Original authors: Alexander Apartsin, Yehudit Aperstein

Published 2026-08-11

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Alexander Apartsin, Yehudit Aperstein

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 the history of medicine's relationship with computers as a story of three distinct upgrades. First, doctors moved from paper charts to digital ones. This was like turning a handwritten diary into a searchable database; it made it easy to find a patient's name and see what was written down, but the computer still didn't understand the meaning of the words. Next, the field upgraded again to "structured data." Now, instead of just reading a sentence, the computer could see specific facts, like "blood pressure is 120/80," allowing it to run checks and spot trends. But a gap remains: doctors often give instructions in casual conversation, like "call me if the pain gets worse" or "get a blood test in two weeks." Right now, the computer sees this as just a block of text. It knows the words, but it doesn't know what to do with them, when to do it, or who is supposed to do it. This paper asks: How do we teach computers to listen to these casual instructions and turn them into actual, executable to-do lists that don't get lost in the shuffle?

The Three Generations of Digital Care

Think of healthcare technology as a video game that has been upgraded three times. The first generation was about digitizing the record. Imagine taking a messy, paper notebook and scanning it into a computer. You can search for words and find files faster, but the computer is just a fancy filing cabinet; it doesn't know that "take two aspirin" is an instruction to do something.

The second generation was about digitizing the facts. This is like teaching the computer to read the notebook and pull out specific numbers: "Patient has a fever," "Blood sugar is high." Now the computer can compare these facts against rules to give warnings or track quality. But there's a catch. Doctors often leave instructions in the "notes" section in plain English, like "Refer to cardiology if symptoms persist." The computer sees the words, but it can't figure out the plan. It doesn't know that this is a future task, who needs to do it, or what condition triggers it.

This paper proposes a third generation: making clinical intent computable. The authors suggest we need a new layer where the computer doesn't just read the text but understands the intent behind it. They call this the "Actionable Clinical Record" (or ACR).

The Problem: The "Lost in Translation" Gap

Here is the real-world trouble the paper highlights. When a doctor says, "Repeat the blood test in two weeks," that instruction is decisive. But in the current system, it's trapped in a paragraph of text. The computer can't automatically schedule that test, assign it to a nurse, or check if it happened later.

The authors point out that this isn't just a minor annoyance; it's dangerous. Because these instructions aren't "computable," they often get forgotten. In one large health system, only about one-third of specialist referrals actually resulted in a completed visit. When instructions get lost in the gap between "what the doctor said" and "what the system did," patients can get hurt, and diagnostic errors happen.

The Solution: The Actionable Clinical Record (ACR)

To fix this, the authors propose a new digital object called the Actionable Clinical Record (ACR). Think of the ACR as a "smart to-do card" that the computer can actually use.

When a doctor speaks or writes an instruction, the system tries to extract it and turn it into this ACR format. An ACR isn't just a sentence; it's a structured package containing specific pieces of information:

Action: What needs to be done (e.g., "run blood test").
Target: What it's for (e.g., "complete blood count").
Actor: Who is responsible (e.g., "the nurse" or "the patient"), not just who spoke.
Time: When it happens (e.g., "in two weeks," not just a random date).
Condition: Under what rules it applies (e.g., "if symptoms persist").
Status: Is it waiting, active, or done?

The authors emphasize that this isn't about replacing the doctor's notes. It's about adding a layer on top of the notes that translates human language into a format the computer's workflow systems can understand and execute.

How It Works: The "Hybrid" Brain

The paper is very careful not to promise that a simple AI chatbot can solve this. The authors argue that while modern language models are great at understanding text, they are bad at being perfectly reliable with time and logic. If an AI guesses the wrong date for a critical test, that's a disaster.

So, they propose a hybrid approach. Imagine a team where a smart, creative AI (the "learner") reads the doctor's note and suggests, "Hey, this looks like a blood test request." But then, a strict, rule-following robot (the "verifier") checks the math. It ensures the "two weeks" is calculated correctly, confirms who is responsible, and makes sure the logic holds up. If the AI is unsure, the system is designed to pause and ask a human doctor to double-check. This ensures that the final "to-do card" is safe and auditable.

What the Paper Actually Found (and Didn't Find)

It is important to note what this paper is not. It is not a report on a new software product that is already saving lives in hospitals. The authors describe this as a framework and a proposal.

The Proposal: They define the rules for this new "third layer" and the ACR format.
The Test: They ran a small, controlled experiment (a feasibility study) on just one specific task: extracting follow-up instructions. In this test, their hybrid system (AI + strict rules) was much better at getting the time and action right than standard AI models alone.
The Limit: They admit this is just a starting point. They haven't proven it works for every type of medical instruction, and they haven't shown that it improves patient outcomes in the real world yet. They suggest that future work needs to test this on real, messy hospital data to see if it holds up.

The Road Ahead

The authors see this as a research agenda. They want the community to agree on a standard way to write these "smart to-do cards" (the ACR ontology). They want to build better ways to handle different languages and complex situations where a doctor might change their mind. Most importantly, they want to change how we measure success. Instead of just checking if a computer "read" the text correctly, we should measure if the computer can actually execute the task correctly.

In short, the paper suggests that for healthcare IT to truly mature, it needs to stop just storing words and start understanding the plans hidden inside them. By turning casual instructions into structured, executable "Actionable Clinical Records," we might finally close the loop on the instructions that keep getting lost, making care safer and more reliable. But for now, it remains a promising idea waiting for more proof.

Technical Summary: Three Generations of Healthcare IT

Problem Statement
Current Healthcare Information Technology (Healthcare IT) is predominantly organized by the technologies it adopts rather than the computational objects it supports. While the field has successfully digitized the clinical record (Generation 1) and made discrete clinical facts computable (Generation 2), a critical gap remains: patient-specific clinical intent expressed in natural language communication remains non-computable.

When clinicians issue instructions such as "repeat the complete blood count in two weeks" or "refer to cardiology if symptoms persist," these directives are captured as narrative text. Consequently, the action, timing, conditions, and responsible actors are not part of the computable substrate. This limitation leads to measurable failures in care coordination, including missed test-result follow-ups and incomplete specialist referrals, contributing to diagnostic errors and avoidable harm. Existing standards (e.g., FHIR CarePlan, ServiceRequest) and paradigms (e.g., computer-interpretable guidelines, process mining) can represent and operationalize intent once it is structured, but they do not address the recovery of intent from unstructured clinical communication.

Methodology and Framework
The paper proposes a conceptual framework organized by the "unit of information" a system makes computable, defining three cumulative layers:

Layer 1 (Record): Focuses on the clinical record. Enabled by transactional databases, it allows for the storage, retrieval, and exchange of documents.
Layer 2 (Clinical State): Focuses on discrete clinical facts. Enabled by structured data, controlled terminologies, and clinical NLP, it supports querying, reasoning, and prediction.
Layer 3 (Clinical Intent - Proposed): Focuses on patient-specific intended actions. This layer aims to recover intent from communication and convert it into an executable form.

To operationalize Layer 3, the authors introduce the Actionable Clinical Record (ACR) as the atomic object. The ACR is defined as a source-grounded representation of a patient-specific intended action, formalized as a tuple:
$ACR = \langle action, target, actor, temporal\ constraint, condition, dependency, status, provenance, confidence \rangle$

Key attributes include:

Required: Action, Status, Provenance (source span, speaker, encounter).
Conditional/Inferred: Target, Actor, Temporal Constraint (normalized time), Condition, Dependency.
Uncertainty: Confidence (a map of calibrated uncertainty for inferred attributes).

The methodology distinguishes between "representational readiness" (moving from mentioned $\to$ interpreted $\to$ actionable $\to$ executable) and the operational lifecycle of the action. The paper advocates for a hybrid architecture where learned components (e.g., Large Language Models) interpret communication to generate candidate actions, while explicit, deterministic components enforce verifiable structure (e.g., calendar arithmetic, dependency ordering, status transitions). This ensures auditability and prevents the generation of unsupported temporal or logical claims.

Key Contributions

The Three-Layer Framework: A re-organization of Healthcare IT history and future direction based on computational objects rather than technology stacks.
The Actionable Clinical Record (ACR): A formal schema for representing patient-specific intent that bridges the gap between unstructured communication and existing workflow infrastructure (e.g., FHIR Task, ServiceRequest).
Executable-Correctness Evaluation Framework: A proposal to evaluate ACR recovery not by text overlap, but by "executable correctness." Metrics include action detection, argument extraction, action-time/condition/actor linking, temporal normalization error, and source-provenance accuracy.
Research Agenda: A defined program covering representation (ontology), inference (reliability, temporal reasoning), evaluation (authentic data benchmarks), and integration (ACR-to-FHIR write-back).

Results and Feasibility
As a conceptual Perspective, the paper does not present a new empirical study. However, it references a companion feasibility study [51] to demonstrate tractability for a narrow subproblem: follow-up instruction extraction.

In this controlled benchmark, a hybrid neural-symbolic pipeline substantially outperformed general-purpose language models on the critical task of action–time pairing.
While general models recognized actions, they failed to reliably bind them to specific times, a known weakness in general-purpose temporal reasoning.
The hybrid approach successfully demonstrated that learned extraction combined with deterministic reasoning can produce verifiable, executable representations.

Significance and Claims
The paper claims that computable clinical intent is a coherent research direction. Its significance lies in providing the constructs necessary to operationalize, evaluate, extend, or falsify this direction:

The ACR serves as a reusable construct for representing intent upstream of existing workflow resources.
The Readiness Ladder (mentioned $\to$ executable) provides a metric for system maturity.
The Evaluation Framework shifts the focus from text similarity to operational safety and correctness.

The authors position the ACR not as a replacement for Electronic Health Records or FHIR standards, but as a complementary layer that recovers intent from communication to feed into those existing systems. The proposal makes testable predictions, such as the growth of machine-actionable FHIR resources relative to free-text follow-ups and the necessity of source-linked, auditable records with selective human review for safe deployment. The paper explicitly states that if direct mapping into existing standards without ACR-specific distinctions can capture all required semantics, the ACR representation would be redundant; similarly, if standard extraction metrics can discriminate unsafe outputs as well as the proposed executable-correctness measures, the evaluation framework would be redundant.