A paper dropped last week from Emmanuel Dupoux, Yann LeCun, and Jitendra Malik—34 pages on why current AI systems don't actually learn and what to do about it. I read it three times. Not because it was hard to understand. Because it was describing, almost exactly, what we've been building for the past 18 months. When you're building something that doesn't fit the current categories, you spend a lot of time wondering if you're crazy. Are we overcomplicating this? Is there a reason nobody else is doing it this way? Did we miss some memo that got circulated to everyone except us? Then a paper from some of the most respected names in the field lands, and it reads like a theoretical justification for your architecture decisions. That's either validation or a very specific hallucination. I'm betting on validation.
The core thesis is something we identified circa September 2024: current AI systems, once deployed, learn essentially nothing. They're trained once, frozen, and shipped. If the world changes—and it always changes—the system can't adapt. Human teams have to retrain it from scratch. The authors call this "outsourced learning," which is a polite way of saying the AI is just expensive middleware. The humans around it do all the actual learning work: curating data, designing training runs, monitoring performance, deciding when things have drifted enough to justify another retraining cycle. The AI executes fixed patterns that humans figured out. That's not learning. That's a very complicated lookup table.
Their proposed solution involves three integrated systems working together. System A handles learning from observation—passive pattern absorption without environmental interaction. Think: watching, reading, accumulating statistics. You know how it is when you watch someone cook a dish a dozen times before you ever touch a pan yourself? That's System A. System B handles learning from action—trial-and-error with feedback, goal-directed behavior, adjusting based on results. That's actually touching the pan, burning yourself, figuring out that medium heat means something different on every stove. And then System M, the meta-controller, which orchestrates when to observe versus act, what data to prioritize, when to be confident versus cautious. The conductor of the orchestra (which is neither here nor there, but I like the metaphor).
Here's the thing: we built all three of these. Starting 18 months ago. Before this paper existed.
Our observation layer—we call it the PatternLearner—watches guidance requests, extracts signatures, builds a library of approaches without intervening. Pure accumulation. Our action layer—the OutcomeProcessor and associated feedback systems—learns from what actually happened when workflows executed. Success rates, failure patterns, quality scores. Every execution generates a learning signal. And our meta-control layer—distributed across multiple services rather than centralized, but functionally equivalent—decides when to act autonomously versus when to consult, based on confidence thresholds that themselves adapt over time.
We didn't call it "System A/B/M." We called it pattern learning, outcome processing, and confidence calibration. We didn't call it "Evo/Devo." We called it pattern leveling—simple patterns at levels 0-2, composed patterns at levels 3+, complexity building on established foundations. Different vocabulary. Same architecture.
The specific alignments are almost eerie. The paper discusses "critical periods" in biological learning—windows where learning is enhanced. We implement probationary periods for new patterns: minimum 10 successful executions before full autonomy. The paper discusses "learning from imagination"—replay and counterfactual reasoning. We don't have this yet (more on that later), but our architecture has hooks for it. The paper discusses "meta-control signals that determine which approach to use in different contexts." Our confidence thresholds do exactly this: above 0.85, act autonomously; between 0.5 and 0.85, act with verification; below 0.5, pause and consult.
I'm not claiming we invented autonomous learning theory. Dupoux, LeCun, and Malik have been thinking about this stuff longer than we've been a company. What I'm claiming is simpler: we arrived at the same conclusions from a different starting point. They analyzed how biological organisms learn across evolutionary and developmental timescales. We tried to deploy frozen AI into healthcare and watched it fail spectacularly. Prior auth takes 45 minutes per case at most health systems. We thought we could automate chunks of that. We built something. It worked for about three months. Then a major payer updated their documentation requirements, and our system kept submitting the old way. Denial rates spiked. Revenue cycle teams started manually reviewing everything. The AI became more work than it saved.
That experience taught us something the paper confirms: frozen models are a dead end. Not because they can't be capable at launch—they can be very capable. But because the world doesn't stay still, and systems that can't adapt become liabilities. You either build continuous learning, or you build continuous retraining pipelines that require human teams that scale linearly with deployment complexity. We chose learning. The serious thinkers seem to agree that was the right call.
The trade-off we made, and the paper discusses this tension explicitly, is between autonomy and controllability. More learning autonomy makes it harder to guarantee the system does what you want. We bias toward controllability. Every action gets logged before execution. Confidence thresholds can be tuned externally. Human oversight is architectural, not bolted on. We call it the Logic Log. It's not a feature. It's the foundation. The latency cost is maybe 200ms per step—acceptable for healthcare workflows measured in minutes, probably not acceptable for high-frequency trading. We know who we're building for.
The paper predicts "decades" of interdisciplinary research before fully autonomous learning systems emerge. I believe that. This isn't a 12-month problem. But here's the thing: the architectural foundations can be laid now. The systems that will eventually achieve genuine autonomous learning are being designed today. Either you're building toward that future, or you're building something that will need to be replaced when it arrives.
We started building 18 months ago. The paper dropped last week. The alignment isn't coincidental—it's convergent. Same observations about the problem. Same constraints on viable solutions. Same conclusions about architecture. A boy can dream, right?