The Radiology AI That Got Lonelier Doctors

A note from Khayyam: In this chapter, I share my insights on the profound challenges of three-body integration, weaving in the wisdom of various experts to illuminate the path forward.

Ternary Integration Framework

In 2016, radiologists at Stanford tested an AI system that diagnosed pneumonia from chest X-rays with 95% accuracy—better than most human radiologists.

The hospital deployed it. Six months later, they shut it down.

Why? Not because it didn’t work. Because it created coordination failures nobody anticipated.

The Deployment Three-Body Failure:

AI Capability (Technology Layer)

• Excellent diagnostic accuracy
• Fast, consistent, scalable
• The technical success

Radiologist Workflow (Human Layer)

• Decades of expertise and judgment
• Contextual understanding of patients
• The human element

Hospital Operations (System Layer)

• Legal liability, insurance, patient trust
• Integration with existing systems
• The organizational reality

What went wrong:

The AI was optimized for accuracy without coordinating with radiologist workflow or hospital operations:

• Radiologists: Felt undermined, stopped trusting AI recommendations
• Workflow: AI slowed down rather than speeding up (integration overhead)
• Legal: Unclear who’s liable when AI is wrong
• Patients: Confused about who’s actually diagnosing them
• Insurance: Wouldn’t reimburse AI-assisted diagnoses

The technology worked. The coordination failed.

This is the pattern of AI deployment failure: optimize one body (capability) while ignoring the others (human workflow, organizational reality).

The Three-Body Integration Reality:

Human Core (People Layer)

• Skills, expertise, motivation, culture
• What people can do and want to do
• The human foundation

AI Enhancement (Technology Layer)

• Capabilities, automation, intelligence
• What technology can add
• The augmentation opportunity

Systemic Context (Environment Layer)

• Organizations, regulations, economics, culture
• What the world permits and rewards
• The reality constraint

Successful integration coordinates all three:

• AI enhances human capability (not replaces it)
• Humans guide AI deployment (not resist it)
• Systems enable coordination (not obstruct it)

Failed integration optimizes one while ignoring others:

• AI replaces humans → Resistance and failure
• Humans ignore AI → Missed opportunities
• Systems block both → Stagnation

This chapter confronts the barriers to coordination—technical, economic, social—and shows how to overcome them through conscious three-body integration.

9.1 Technical and Computational Barriers

Individual Capability ←→ Collaborative Intelligence ←→ Measurement Systems

The technical barriers to coordination aren’t just computational—they’re architectural.

The Technical Three-Body Challenge:

Individual Systems (Component Layer)

• AI models, databases, applications
• Each optimized independently
• The siloed excellence

Integration Infrastructure (Coordination Layer)

• APIs, protocols, standards
• How systems communicate
• The connection problem

Measurement & Monitoring (Verification Layer)

• How we know coordination works
• Performance, reliability, value
• The accountability challenge

Why Technical Integration Fails:

We build brilliant individual systems without coordination infrastructure:

Example: Healthcare IT

Electronic Health Records (EHR): Each hospital has sophisticated system Problem: Systems don’t coordinate—can’t share patient data across hospitals Result: Fragmented care, repeated tests, medical errors

The coordination failure:

• Individual systems optimized (each EHR works well internally)
• Integration infrastructure missing (no standard coordination protocol)
• Measurement inadequate (no way to track coordination failures)

The Three-Body Technical Solution:

Don’t just build better systems—build coordination infrastructure.

Coordination-First Architecture:

1. Design for Coordination: Systems built to coordinate from day one
   • Standard APIs and protocols
   • Interoperability as requirement
   • Coordination as core feature
2. Enable Bidirectional Learning: Systems improve from coordination
   • Feedback loops across systems
   • Shared learning infrastructure
   • Coordination intelligence
3. Measure Coordination Health: Track coordination effectiveness
   • Not just individual system performance
   • But coordination outcomes
   • Emergent value from integration

François Chollet, the brilliant mind behind Keras, taught me that while he created Keras to make deep learning accessible, accessibility alone isn’t enough—we need coordination infrastructure. He articulated the three bodies of technical debt:

1. System Complexity (Code Layer): This is how complicated systems become, the technical implementation details, what we often call “spaghetti code.” It’s about what we build.
2. Integration Overhead (Coordination Layer): This refers to how hard systems are to coordinate—the APIs, protocols, and dependencies. It’s the “coordination tax” we pay for what we maintain.
3. Cognitive Load (Human Layer): This is how much developers must understand, the mental models and abstractions required. It’s the comprehension burden, what we think about.

Chollet explained that as systems grow, coordination overhead dominates. More components mean more integration points, which lead to more failure modes, increasing cognitive load, and ultimately stifling innovation. This, he warned, is the coordination death spiral: complexity creates coordination overhead, which creates cognitive load, which in turn creates more complexity.