Autonomous vehicles replaced their entire hand-engineered stack with a single learned model. Healthcare's care coordination pipeline is waiting for the same transition.
For a decade, the self-driving car industry built its stack the way you'd expect engineers to build it: one module at a time. Perception to detect objects. Prediction to forecast where they'd go. Planning to decide a path. Controls to execute the steering. Each module was owned by a different team, connected by explicit interfaces, and improved by engineers hand-coding rules for every new edge case. A pedestrian stepping off a curb at dusk? Write a rule. A construction cone half-fallen into the lane? Write another rule. The system didn't get better by driving. It got better by engineers working overtime after crashes.
Then something changed. The best AV teams — Tesla with FSD, Wayve with LINGO-2, NVIDIA's Alpamayo — started collapsing the entire pipeline into a single end-to-end learned model. Sensor data goes in, driving actions come out. The boundaries between perception, prediction, planning, and controls blur. The system learns the whole task jointly from dense driving data. It gets better by driving. Every mile is training data. The edge cases that used to require hand-coded rules get resolved by the model seeing enough examples.
This transition — from a hand-engineered pipeline of specialized modules to a single learned model — is the most important architectural shift happening in AI right now. And almost nobody has noticed that healthcare is next.
The modular stack wasn't stupid. It was the right architecture when data was scarce and compute was expensive. If you can only afford to train small models, you want each one focused on a narrow sub-problem. Perception is hard enough on its own without also asking the same model to plan. And explicit interfaces between modules give you interpretability — when the car makes a bad decision, you can trace exactly which module failed.
What changed was the data. Dense sensor logs from millions of miles of real-world driving created a dataset rich enough that a single model could learn the full task jointly. And critically, end-to-end training solved a problem the modular stack never could: error propagation across module boundaries. When perception makes a small error in the old stack, prediction compounds it, planning compounds it further, and by the time controls executes, the car is reacting to a world state that doesn't exist. In the end-to-end model, errors in early representations get corrected by the learning signal from the final driving outcome.
The modular stack failed gracefully until it didn't. The learned model failed messily at first, then got better and better. One architecture has a ceiling. The other has a scaling law.
Now look at how care coordination works today. A patient with multiple chronic conditions — diabetes, CHF, depression — is managed through a pipeline that looks almost identical to the old AV stack. Separate systems handle each piece. A risk stratification model flags the patient as high-risk. A care gap engine identifies overdue screenings. A utilization management team reviews authorization requests. A nurse care manager makes outreach calls from a prioritized list. An analytics dashboard reports outcomes quarterly.
Each of these functions was built by a different vendor, maintained by a different team, and connected by manual handoffs and batch data feeds. The risk model doesn't know what the care manager said on the phone last Tuesday. The care gap engine doesn't account for the prior authorization that's been stuck in queue for three weeks. The utilization review is blind to the patient's trajectory over the last six months. Sound familiar?
This is the modular stack. And it has the exact same failure mode: errors compound across module boundaries, each component optimizes its own sub-problem in isolation, and the system gets better only when humans manually patch the gaps between components.
In January 2026, Yann LeCun left Meta to start a company. That sentence alone should stop you. LeCun won the Turing Award — computing's Nobel Prize — for inventing convolutional neural networks. He spent twelve years at Meta, first building FAIR into one of the world's top AI labs, then serving as Chief AI Scientist. He is, by any measure, one of the three or four most important people in the history of deep learning. When someone like that leaves to start something new, you pay attention to what they chose to build — and where they chose to build it.
The company is AMI Labs. The CEO is Alex LeBrun, who worked under LeCun at FAIR for four years before leaving to co-found Nabla, a healthcare AI company that now serves 85,000 clinicians across 130+ organizations. LeBrun didn't just show up from some adjacent field — he spent years inside LeCun's research lab, then years inside healthcare operations. AMI Labs is raising at a reported $3.5 billion valuation before launching a product. And their first vertical? Healthcare.
LeCun has been the most prominent critic of LLMs in the AI field. His argument: LLMs predict the next word. They don't understand the world. An agentic system that takes actions with real consequences — prescribing a medication, scheduling a surgery, routing a referral — cannot work reliably by generating plausible-sounding text. It needs a world model that can simulate consequences before acting. That's what AMI Labs is building. And they launched with an exclusive partnership with Nabla, giving them immediate access to a deployed clinical network for real-world validation.
LeCun and LeBrun's provocation reframed everything I'd been thinking about: LLMs predict words; world models predict patients.
Think about what a good physician actually does. Before ordering a test or writing a prescription, they're running a simulation in their head: if I start vasopressors now, what does this patient's MAP look like in four hours? If I discharge today, what's the readmission risk in fourteen days? The best clinicians aren't following flowcharts. They're modeling futures. They are, functionally, world models running on biological hardware.
The end-to-end transition for healthcare means replacing the fragmented vendor pipeline with a single model that ingests the full patient state — claims, labs, clinical events, social determinants, care manager notes — and outputs a coordinated care plan. Not just "this patient is high risk" (that's the perception module alone). Not just "this screening is overdue" (that's the care gap module alone). But: given this patient's full trajectory over the last two years, here is the optimal sequence of interventions over the next thirty days, ranked by expected impact on outcomes.
The model doesn't just flag. It simulates. It evaluates candidate care plans against the patient's predicted trajectory before any action is taken. That's the difference between an LLM (generate a plausible next step) and a world model (simulate the consequences of each option).
This sounds counterintuitive, so let me be precise about what I mean. Building a general world model that understands all of physics — every possible road condition, weather pattern, pedestrian behavior — is an extraordinarily hard problem. That's why AV companies needed millions of miles and billions of dollars to get to where they are today. The domain is open-ended. The tail of edge cases is essentially infinite.
Healthcare's care coordination problem is bounded. You don't need a universal model of human physiology. You need one that predicts readmissions and care gap closure for a specific ACO population with specific chronic conditions. The patient state space is large but enumerable. The intervention set is finite. And critically, the data already exists — longitudinal patient event streams (clinical events, interventions, outcomes) that are inherently sequential, already causally structured, and already labeled by what happened next.
This is what gets me up in the morning at Kaigo. We're sitting on exactly the kind of data that makes the end-to-end transition tractable. Not because we cracked some research problem — but because the structure of the domain means the data flywheel can start spinning immediately. Every patient interaction generates training signal. Every care plan outcome is a label. The model doesn't need millions of miles. It needs thousands of patient trajectories in a bounded clinical domain. We have those.
The data scarcity problem that makes general world models so hard is already solved in healthcare. The data is there. It's structured. It closes the loop. What's missing is the architecture to learn from it end-to-end.
The practical implication is this: today, a care coordinator with a panel of 200 patients opens their EHR in the morning, looks at a static risk-stratified worklist, and makes judgment calls about who to call first and what to discuss. The risk score was generated last week from a model that doesn't know about the ER visit on Saturday. The care gap list was refreshed yesterday but doesn't account for the specialist referral that's been pending for three weeks. The coordinator fills the gaps with experience, intuition, and an enormous amount of manual work.
The end-to-end version: the model has already ingested the ER visit, the pending referral, the medication adherence data from the pharmacy benefit, and the patient's historical response to prior outreach attempts. It doesn't present a static list. It simulates the next thirty days for each patient under different intervention sequences and surfaces the highest-impact actions, in order, with expected outcomes attached. The coordinator still makes the call. But the call they make is informed by a simulation of consequences, not a static flag from a siloed system.
That's the difference between L2 and L4. L2 gives you alerts and worklists — it helps, but the human is still doing all the integration across systems. L4 gives you a model that's already done the integration and is presenting you with evaluated options. The human supervises and overrides. They don't assemble.
Every industry that generates enough sequential, causally-structured data will eventually make this transition. The modular stack — specialized components connected by explicit interfaces, improved by human effort — will give way to end-to-end learned systems that improve from their own operational data. It happened in machine translation. It happened in speech recognition. It's happening now in autonomous vehicles. Healthcare is next, and in some ways, it's better positioned than any of them.
The question isn't whether this transition will happen. It's who builds the data flywheel first — who accumulates enough patient trajectories in a bounded clinical domain to make the end-to-end model work, and then uses the model's predictions to generate even better data.
I know which domain I'm betting on.