Closing the Loop

A clinician opens their shift by reading an AI-generated summary of the patient they're inheriting. The summary is fluent. It hits the right beats: diagnosis, treatment, response. They nod, take signout, and start the day. Three hours later they realize the AI quietly dropped the patient's penicillin allergy. It wasn't in the structured allergy list the model was pulling from. It was buried in a narrative note from a prior outside-hospital admission, never reconciled into the active record. The model didn't know to look there. The clinician didn't know it didn't know. The patient is fine. The next one might not be.

This is what an open-loop compression system looks like. Something compressed an enormous amount of information into a small package. The package crossed a wire. Something else on the other side decompressed it into a picture of the patient. Nobody checked whether the picture matched the patient. The conversation worked the way most conversations seem to work, until it didn't.

Many human handoffs and current AI workflows have this shape. The sender encodes. The wire carries. The receiver decodes. And then nothing. No signal back to the sender that the decoding landed wrong. No mechanism for the receiver to flag "I'm not sure I have the full picture." No way for the codec on either side to update when reality drifts away from the agreement. We compress and decompress as if it were one-way traffic. It isn't. It's just that the return traffic has been silently broken for so long we've forgotten it should be there.

Compressing is mandatory in any clinical system. The work is to make the compression inspectable, uncertainty-preserving, receiver-matched, and correctable before it drives action.

There is a principled way to do better. High-stakes communication between bounded agents tends to need six things to keep errors from compounding silently.

A matched codec. Either the sender shapes its encoding to this receiver's priors, or the receiver has been pre-loaded with the priors the sender will use. The efficiency of any message is set by how much the receiver already shares.

An externalized shared codec. When the agreement is too large to hold in both heads, both ends point at the same external storage. Dictionaries, ontologies, schemas, knowledge bases, and in current AI systems, the retrieval indexes and embedding spaces that make external knowledge reachable at inference time. The codec doesn't have to fit in the message; it has to be reachable from both sides.

Decompression verification. The sender gets feedback that the receiver's reconstruction actually landed. In medicine: read-backs. In aviation: explicit confirmations. In code: type checks at the boundary. Without verification, errors propagate forward and look like everything is fine.

Uncertainty markers in the message itself. When the sender is hedging, the message carries that hedge, and the receiver decompresses with appropriate error bars. Strip the markers and the receiver fills in with a confidence the sender never had.

Iterative expansion at minimum bandwidth. Start with the smallest pointer. Expand only when the receiver signals confusion. Don't pre-emptively send the whole picture. Questions before lectures.

Active maintenance against codec drift. Terms change meaning. Audiences turn over. Training data ages. Without active upkeep, the codec degrades silently while everyone involved still feels fluent. Drift is the failure mode you don't notice.

Modern AI is groping toward this list, one property at a time.

Retrieval-augmented generation, or RAG, implements part of the second property: external memory the model can reach at inference time (Lewis et al., 2020). Whether the human at the receiving end can inspect the same retrieved evidence is a UI choice, and many systems don't expose it. Either way, retrieval is itself a codec problem: which chunks to surface, in what order, for which query, all require their own compression and decompression. Bad retrieval can look fluent and still be wrong.

Prompting, in-context examples, and fine-tuning implement parts of the first property, adapting the model's effective codec to the task or audience. The limitation is that the match is set up before the conversation starts. Modern chat models can ask clarifying questions, but most deployed systems are configured to produce an answer in a single pass. They don't stop to ask whether this user already knows the standard playbook before walking through it.

Chain-of-thought, critique-revise loops, verifier models, and interpretability tools gesture at the third, making the model's process inspectable, scoring its own answers, sometimes catching errors before the output ships. These help. They are not the same as receiver-side verification: a model can generate reasoning that does not faithfully reflect how it arrived at its answer (Turpin et al., 2023), and a model checking itself is structurally different from a receiver confirming that the right meaning landed on the other end of the channel.

Verbalized confidence research tries the fourth, uncertainty markers. Get the model to say when it's guessing. The limitation is technical and stubborn: self-reported confidence is often only weakly calibrated, especially out of distribution, and should not be treated as a standalone probability of correctness (Xiong et al., 2024). The marker is there in form, often unreliable in substance.

Agentic systems and multi-turn loops attempt the fifth, iterative expansion, and often bundle in retrieval, reflection, and tool-based checks along the way. The limitation is that the loops are expensive and the stopping criteria are brittle. Without a clear signal of "okay, you have enough now," they can spiral or stall.

The sixth, active maintenance against drift, is currently handled in fragments: monitoring dashboards, prompt and policy updates, knowledge-base refreshes, occasional evals, sometimes a model swap. The shape that's mostly missing is semantic drift detection: noticing when what the model treats as the prototypical patient, the typical sign-out, the expected workflow, has quietly drifted away from what the receivers are actually doing. Most teams catch this reactively, after someone notices a failure, rather than at the moment it starts to drift.

No standard clinical LLM architecture in widespread deployment robustly implements all six end-to-end. Many systems implement partial versions of three or more, with real results on the properties they cover. But bigger context windows are not the integrated solution. Better prompts are not. Smarter retrieval is not. The integrated solution is all six, with explicit handoffs between them, and (this is the part most current stacks still mostly skip) with a return channel that closes the feedback loop from the receiver back to the sender. Each property governs a different failure mode of finite representation: codec mismatch, inaccessible context, unverified reconstruction, hidden uncertainty, over- or under-expansion, and drift.

Take Epic's generative AI for In Basket replies, now in routine use across major health systems. A primary-care physician opens their morning queue. The patient at the top has written asking whether they can stop their statin "now that the cholesterol number is good." The AI has pre-drafted a fluent, empathetic reply: general advice about cholesterol management, an offer to discuss at the next visit. The patient is on the statin for secondary prevention after a prior MI two years ago. That fact lives in a cardiology note from another system, not in the structured problem list the draft pulled from. The physician, twelve messages into a hurried hour, edits a sentence and clicks send. Nothing in the loop knew the draft had decompressed the wrong patient. Systematic review of these tools finds quality comparable to human replies in style, alongside documented risks to patient safety and inconsistent performance across studies (npj Health Systems, 2025).

The hardest property is the third. Decompression verification. Most current LLM-based clinical copilots, summarizers, and recommendation tools are largely open-loop at the point of care. Existing clinical decision support provides partial loop closure (read-back protocols, structured order sets, alerting that demands acknowledgment), but it is fragmented across codec hops and inconsistent across deployments. The piece missing in almost every stack is semantic verification: a check that the clinician's reconstruction of the AI's representation actually matches it. The model generates a summary, a recommendation, an alert. The clinician reads it. The clinician acts on it. Most systems do not detect semantic mismatch in real time. Nothing notices when the model's confident answer landed in the clinician's head as a different confident answer. The two ends produce fluent output and fluent reading, and no signal closes the gap between what the model represented and what the clinician understood.

What would it mean to close that loop? In its simplest form: the AI's output is structured so that the clinician's read-back is checkable. The system exposes the specific patient-state it is representing, explicitly, with its own uncertainty markers, and detects meaningful divergence between that representation and the clinician's apparent working model. Divergence may indicate misunderstanding; it may also indicate deliberate override or new information the system didn't have. The point is that the divergence becomes visible rather than hidden. When the gap matters, the system surfaces it in time. The clinician confirms or corrects. The system updates how it represents and presents information to this clinician, its user model, not its underlying clinical reasoning. Both sides drift toward each other instead of apart.

Two verifications are easy to confuse. Source verification asks whether the AI represented the patient correctly: did the model build the right patient-state from the chart and the source data? Receiver verification asks whether the clinician reconstructed the AI's representation correctly: did the model's patient-state land in the clinician's head as the same patient-state? A closed-loop system needs both. The model can be right and the clinician's read can still be wrong; the clinician's read can be right and the model can still have built the wrong patient. Both failure surfaces show up at the bedside as the same thing: a clinician acting on a picture that does not match the patient.

The point is to make the AI part of a system that checks itself. Smarter is downstream of that. Current AI is good at the first half of communication: compress, encode, transmit. The second half is where it falters: verify, signal uncertainty, close the loop. The work of clinical AI, and probably of every other high-stakes AI deployment, is finishing the loop.

This matters because of who sits at the far end. An unbounded inference accumulates for every codec hop that does not check its own decompression, and the patient is the one those inferences eventually fall on. The right architecture for medical AI is one where the AI knows when the human on the other side did or did not understand it, and where neither the model nor the human is allowed to confidently sleepwalk past the gap. Smartest possible compressor is the wrong target.

---

Six Essays on Compression · Preface · I · II · III · IV · V · VI · Coda · Postscript