Essay · April 2026 · 12 min read

Engine vs Bolt-on:
where AI in online learning actually stands

Most products have added AI. Few have built it into the loop that decides what to teach next. That's the real shift — and the market is split on whether to address it.

Contents ›
  1. 01Opening
  2. 02Where the market is now
  3. 03What players are actually doing
  4. ↳The missing piece
  5. 04What an engine actually requires
  6. 05Where this is going
  7. 06Sources & notes

Recently I needed to systematically refresh a specific skill. So for the first time in a while, I came back to online courses.

In the background, I've been hearing it more and more often: "education is broken," or even "traditional learning is dead." The argument goes that in a world where a new framework ships every week, industries shift overnight, and AI automates a good chunk of the work, slow broad-based learning can't keep up. Even what counts as "modern" learning today — Phase 3 sidecar products and online courses on top of static content — already starts to feel late. Here's my take: that part is true. But the problem isn't where people first look.

I opened a few popular platforms, clicked around, and within a couple of days caught myself on one observation. They all looked better than before: more courses, more accessible, more convenient. And of course AI was everywhere — assistants, explanations, summaries, hints. But when I looked at what the AI was actually doing, the same picture kept showing up. It sat off to the side, as an add-on. The course itself was the same one as ten years ago, just with a chat next to it.

The real shift in EdTech right now isn't about producing more content or making it more motivating. It's about the control loop — where AI sits relative to the learning itself. By delivery loop I mean the repeated cycle: choose the next move, deliver it, check evidence, update learner state, decide again. Content still matters, but its role changes — from finished product to structured fuel for that runtime. Most products today have AI beside learning. Very few have AI as the learning runtime. That's the split.

Below: where the market is now, what the players are doing, and where this is going.

Market state

Where the market is now

This shift didn't come out of nowhere. It moves in step with what AI systems can actually do — first adaptive models, now large language models — and it's been running for over a decade. Roughly, that trajectory has four phases.

Four phases of AI in online learning, 2010 to 2026 Four ascending steps along a timeline from 2010 to 2026. Phase 1 static digital, Phase 2 interactive practice, Phase 3 AI assistant beside the course (where most products are now, highlighted), Phase 4 AI inside the delivery loop (a direction, dashed). Common mainstream pattern Frontier — different routes, same destination 01 Static digital 02 Interactive practice Measurable evidence 03 AI assistant beside Chat next to the course Bolt-on 04 AI in the loop Engine, not a helper Direction, not state 2010 2015 2020 2025 → PLAYERS Coursera (early) edX Lynda PLAYERS Codecademy DataCamp (early) Stepik PLAYERS Coursera Coach Codecademy Assistant Khanmigo FRONTIER MATHia · ALEKS · DreamBox IXL · Area9 · Duolingo Eedi · DataCamp Squirrel AI
Fig. 1 — Four phases. Phase 4 is dashed because the LLM-native version is where nobody is fully there yet.
  1. 01

    Static digital

    Lecture moved to the browser.

    Analog education was digitized: video lectures, quizzes, linear courses. No AI here. The base shape of many courses today still sits in this layer.

    Players Coursera (early) · edX · Lynda

  2. 02

    Interactive practice

    The first time the system can see what the learner does.

    Sandboxes, executable exercises, in-browser checking. Domains with executable evidence adapt better than conversational-only learning. This is the substrate that lets engines exist.

    Players Codecademy · DataCamp (early) · Stepik

  3. 03

    AI assistant beside the course

    Chat next to the course; the engine is unchanged.

    An LLM layer arrived. The chat knows the course context, partly sees the learner's progress, helps explain, fill gaps, get unstuck. But it doesn't decide what to show next — the static structure still does. Most are AI layers added on top of Phase 1 or 2 platforms.

    Coursera Coach — assistant on top of Coursera courses. Course structure and pacing unchanged.
    Codecademy Assistant — guidance and explanations inside Codecademy exercises. Decisions still come from the static path.
    Khanmigo — Khan Academy's AI tutor surface. Helps the learner navigate; doesn't replan the curriculum.

    MARKETMuch of the visible mainstream market sits here today. This is bolt-on.

  4. 04

    AI inside the delivery loop

    The path adapts in real time around one learner.

    AI is part of the delivery loop: it decides what to show, when to assess, how to adapt, when to slow down. Several classical adaptive engines have operated this way for years, using probabilistic models, mastery logic, and explicit learner state — the path adapts in real time, but the lesson ingredients are pre-authored. In the LLM-native version of this, even the lesson ingredients can be assembled dynamically. That's where nobody is fully there yet.

    MATHia, ALEKS, DreamBox, IXL, Area9 Lyceum — classical ITS / adaptive engines with explicit learner state, skill graphs, and evidence-based progression. Mature mastery loops. No LLM in the decision logic itself.
    Duolingo Birdbrain — modern ML-driven engine with concept-level proficiency modeling. LLMs sit above as the conversational surface.
    Eedi — diagnostic-driven adaptation with curriculum-aligned AI tutoring; one of the strongest public evidence trails among newer entrants.
    DataCamp — publicly framed as moving toward an AI-native, adaptive learning engine where lessons, examples, and challenges adapt in real time around the learner. The direction is clear; much of the technical detail remains proprietary.
    Squirrel AI — adaptive engine for academic tutoring at scale. Ambitious claims, less independent transparency.

    MARKETSeveral classical engines are already here. The convergence with LLM-native flexibility is what's still missing.

Where this leaves us Most products sit in Phase 3. Several classical adaptive systems are already in Phase 4 — and they're not the products that get the most attention. What's still missing is their convergence with LLM-native flexibility. That's the next thing worth looking at closely.

Players

What players are actually doing

Section 2 was about evolution. This is about typology — where players actually sit today, and what's surprising once you look closely.

"AI tutor" is not a category

Almost every learning product now uses the phrase "AI tutor." It tells you nothing. The same phrase covers a chat that summarizes a video, a content generator that writes practice problems, a career-path recommender, and a runtime that decides what to teach next. Four different things. The category isn't AI — it's where AI sits in the learning loop.

Four real categories

  1. 01AI as sidecar

    A chat or assistant beside static content. Helps explain, fill gaps, get unstuck. The course structure decides everything else.

    Khanmigo · Coursera Coach · Pearson AI Study Tools · Chegg · Quizlet · Memrise · Codecademy Assistant

    Common mainstream pattern

  2. 02AI as content / authoring layer

    Generates explanations, examples, study guides, practice problems on demand. Upstream automation. Downstream of the learner, the structure is still mostly fixed.

    Coursera content generation · Google LearnLM · Quizlet authoring · parts of Codecademy · Smart Sparrow lineage

  3. 03AI as learning-path orchestration

    Helps learners figure out what to study next based on roles, skill gaps, career goals. Builds paths from existing modules and courses — a smarter constructor on top of the existing catalog. Useful, but still building new shapes from old blocks.

    LinkedIn Learning · Udemy · Sana · Coursera path recommendations

  4. 04Adaptive engine / AI inside the delivery loop

    Not necessarily LLM-based. A runtime inside the learning itself — not a constructor of courses. Decides what to show, when to assess, how to adapt, when to advance. Builds the road under the learner's feet, one move at a time. Learner state is explicit and updated by evidence.

    ALEKS · MATHia · DreamBox · IXL · Area9 · CENTURY · Cognii

    The actual frontier

What follows is a qualitative map. Positions are approximate, based on public evidence — not benchmark numbers.

Where players sit on two axes: orchestration sophistication vs AI-native adaptive delivery A 2D positioning map. X-axis is skill orchestration sophistication (0-100). Y-axis is AI-native adaptive delivery score (0-100). Player positions reflect public evidence quality and architectural maturity. The convergence frontier in the top-right is sparsely populated. Convergence frontier — sparsely populated Adaptive engines Sidecars + content Orchestrators SKILL ORCHESTRATION SOPHISTICATION → AI-NATIVE ADAPTIVE DELIVERY → High Mid Low Mid High ALEKS MATHia Duolingo Eedi Area9 DreamBox IXL Knewton Alta DataCamp Cognii CENTURY Squirrel AI Sana Codecademy LinkedIn Learning Quizizz Udemy Khanmigo Coursera Coach Quizlet MagicSchool Pearson AI Memrise Chegg Positions reflect public evidence and architectural maturity. The convergence frontier (top-right) is sparse — and the highest-Y players are rarely the most-hyped.
Fig. 2 — Approximate positioning based on public evidence. Qualitative map, not benchmark scores.
The surprise

The most architecturally mature systems aren't the ones generating the most GenAI excitement

They're the classical adaptive engines that have been in production for years. ALEKS, MATHia, Area9, DreamBox, IXL, CENTURY — none of them lead with "AI tutor." They have something better: an explicit learner state, a skill or concept graph, mastery-based progression, evidence-qualified advancement, remediation logic, and an assessment loop. ALEKS, for example, describes Algebra 1 as a domain with a few trillion feasible knowledge states, using Knowledge Space Theory to infer what a learner has mastered and what they are ready to learn next — and has done so since long before LLMs existed. Older AI traditions sit underneath this: knowledge tracing, mastery modeling, cognitive tutors. None of them an LLM. All of them adaptive.

Most of the GenAI sidecar products don't have any of this. They have a chat surface and a course catalog. An LLM doesn't make a system adaptive on its own. It gives you flexibility in explanation, generation, and dialogue. Without learner state and evidence, that flexibility is just smarter helping. The engine is what turns flexibility into adaptation.

But these engines work because their conditions hold.

Three things had to line up: a curriculum that doesn't change every quarter, decades of learner traces, and a skill graph that pedagogical research has refined over years. School algebra has all three. Language learning has them. Compliance training has them. That's why ALEKS and MATHia and Duolingo's Birdbrain look so polished — they were built on top of stable structure, with rich data behind every decision the model makes.

What's worth taking from these systems is the architecture: the mastery loop, the evidence gates, the explicit learner state, the policies for what to do when a learner gets stuck. That part transfers. The conditions don't. Modern AI tooling, framework migrations, security practices, the work most professionals do day-to-day — none of these have a stable curriculum, decades of data, or a refined skill graph. The classical playbook can't be copied directly into them.

That's the gap LLMs fill. Bootstrap a skill graph in hours instead of years. Generate ingredients without waiting for editorial cycles. Operate without the data backbone the older engines had. Not as a replacement for the architecture, but as the thing that lets the architecture reach domains where its original conditions don't hold. The classical engines are the proof that this kind of system can work. The LLM is what makes it work outside the few places it was originally built for.

The frontier is convergence

Classical engines have the loop. Sidecars have flexibility. The frontier is the combination.

The interesting frontier isn't classical engines and it isn't GenAI sidecars. It's the products trying to combine both. Existing adaptive engines have the loop, but their content is rigid — pre-authored, slow to update, locked to the curricula they were built for. LLMs solve exactly that constraint, if they're contained correctly.

Duolingo's Birdbrain plus the LLM conversation layer in Max. Eedi's diagnostic-driven adaptation paired with curriculum-aligned tutoring and unusually strong evaluation evidence. DataCamp's stated direction toward AI-native, adaptive learning where lessons and exercises adapt in real time around the learner, with much of the technical detail remaining proprietary. Sana in the enterprise direction. Squirrel AI claiming the most ambition.

What unites them isn't a shared architecture. It's a shared bet: that the next generation of learning systems will look like a classical engine with an LLM layer on top, not an LLM with a course catalog beside it.

The missing piece

What classical engines miss — and how an LLM, held tight enough, fixes it

Classical engines already have the loop. They hurt in three specific places: where they can reach, how fast they can author, and how rigidly they teach and check. An LLM, held tight enough, fixes each one without taking the engine over.

The future is not an LLM pretending to be a course. It's an adaptive engine with an LLM layer.

The engine decides the learning move. The harness constrains what the LLM is allowed to generate, check, or adapt inside that move.

The missing piece — three classical strengths, three LLM contributions, joined inside a harness Three arc segments arranged around a center pie represent classical adaptive engine strengths: mastery loop (right), pedagogical structure (bottom-left), teaching surface (top-left). Each is paired with a pain point. At the center, a smaller circle is divided into three pie sections, each representing a specific LLM contribution, aligned with the arc it addresses. Dashed connectors link each pie section to its arc segment. CLASSICAL STRENGTHS three things engines already do well LLM CONTRIBUTIONS held tight, bound to a specific need Mastery loop on mapped domains — stuck in mature subjects Pedagogical structure per skill node — authoring is slow Teaching surface explains and checks — rigid both ways Generate graphs Generate ingredients Adapt delivery + check
Fig. 3 — Three classical strengths (outer arcs), three LLM contributions (inner pie). Each LLM contribution stays harnessed — bound to one specific pain, not free to redesign the engine.
  1. PAIR 01 · REACH

    Engines that knew algebra, now reach new fields

    Old engines worked because the curriculum sat still. Modern fields don't.

    Strength

    Mastery loops on mapped domains. ALEKS works because school algebra has decades of pedagogical structure behind it.

    Pain

    Skill graphs take years to author by hand. In fast-moving domains — modern data tools, framework migrations, AI itself — skills now appear faster than curricula can be written.

    LLM contribution

    Bootstrap graphs and prerequisite structure for new domains in hours. Refine with expert review instead of building from scratch.

    Combined

    Adaptation reaches into territory where the curriculum is still being written.

    Engines that knew algebra can now reach new fields.

  2. PAIR 02 · AUTHORING SPEED

    Months of editorial compress to minutes of generation

    Editorial scales with people. Generation scales with compute.

    Strength

    Each skill node has deep pedagogical ingredients — explanations, examples, exercises, hints, transfer checks — all linked to specific learning objectives.

    Pain

    Adding a new skill takes weeks. Updating one as the underlying technology shifts takes months. The system can't keep up with any domain that isn't slow-moving.

    LLM contribution

    Generate ingredients on demand, contained within the existing pedagogical structure of each node. Pre-author what's stable, generate what's volatile.

    Combined

    Authoring stops being the bottleneck. The cycle compresses from months to minutes.

    Months of editorial compress to minutes of generation.

  3. PAIR 03 · SAME SKILL, YOUR LANGUAGE

    Same skill, your language

    A tutor that meets you in your language — and listens in it too.

    Strength

    Picks the right next skill, the right next move. The path adapts.

    Pain

    One explanation written for everyone. One closed form for every check. The aviation engineer and the doctor get the same paragraph and answer the same multiple choice. The interaction is rigid both ways.

    LLM contribution

    Reshape both sides. Explanations adapt to the learner — domain, language, prior knowledge. Assessments take open responses, code, dialog — evaluating the same skill, in the form that fits this person.

    Combined

    The skill stays. Both how the system teaches and how it checks meet the learner halfway.

    Content adapts to who's reading it. So does the test.

The engine that results is hybrid. Probabilistic models for knowledge tracing. Deterministic validation for advancement. An LLM contained inside a tight harness for content generation, explanation, and qualitative assessment. Three different kinds of intelligence in one loop, each handling what it's actually good at.

A note worth keeping visible: humans don't disappear from this picture. Experts still own the skill graph and the validation logic. They review the ingredients an LLM generates, catch where the model invented a prerequisite, and approve when the system proposes a new micro-skill it inferred a learner needs. The flow runs both ways — an LLM helps the expert build courses faster from raw materials, and the expert keeps the engine honest. That bridge between expert authoring and engine runtime is its own engineering problem, and a topic for another article.

Where this leaves us One thing the public data doesn't yet show: which of these systems actually produce better learning outcomes. The architecture is observable. The learning quality, by category, is not — at least not publicly. That gap matters more than which product wins. To answer how the harness is actually built, leave the product labels behind and look at the machinery.

Architecture

What an engine actually requires

If the four phases describe where the market is, the next question is what an engine actually consists of. Not LLM tricks, but the architecture that makes "AI in the loop" possible. Three components, working together.

The practical difference is simple. Most products today solve how to deliver content better — clearer explanations, smarter chat, better generation. Few solve what to deliver next, and when to advance. A sidecar answers when asked. An engine decides the next learning move.

The ideal is simple to state and hard to build: when a learner needs a specific skill, the system finds the shortest path through the gaps in their current state, and delivers exactly the material they need, in the form that lands for them. Everything below is in service of that.

Engine architecture: three components in orbit around the learner A learner profile sits inside the inner circle (goals, language, mastery, gaps, current move). Around it, the teaching loop (annulus) holds runtime state — evidence strength, hint dependence, next reinforcement, pacing — and runs path adaptation on one side, content adaptation on the other. Outside the loop, ingredient icons (video, text, code, exercise, hint) represent the content the loop pulls and shapes for the learner. On the left, the skill graph shows nodes that compose: A, B, C, D into AB, AC, AD, ABC, ABCD. Some are mastered, some are on the active path to target ABC, some are off-path. The loop fetches from the active node into delivery. SKILL GRAPH composable skills · each node has its own ingredients INGREDIENT TYPES explanations · examples · exercises · hints · transfer checks A B C D AB AC AD ABC ACD ABD ABCD already mastered active path through learner's gaps untouched / off-path learner · goals + context · language · skills mastered · weak topics / gaps · current move teaching loop decides what · adapts how · evidence strength · hint dependence · next reinforcement · pacing policy PATH adaptation CONTENT adaptation video text </> code exercise ? hint INGREDIENTS pulled by the loop, delivered to the learner Three dots inside ABC — multiple ingredient variants. Same concept, different shape per learner.
Fig. 4 — Engine architecture. Skill graph on the left feeds the teaching loop, which holds the learner's profile inside it and pulls ingredients (right) shaped to the moment.
  1. 01 COMPONENT

    Course graph + ingredients

    The substrate the engine operates on. A skill graph (nodes are concepts, edges are dependencies) plus a library of structured ingredients attached to each node — explanations, examples, exercises, hints, alternative framings, transfer checks.

    An ingredient isn't a 40-minute video. It's an atomic unit with metadata the engine can reason over: which skill it teaches, which prerequisites it assumes, how it's been used, how often it works.

    Without ingredients, the engine has nothing to deliver. Without structure, the engine has nothing to reason over. This is the upstream system, and it is most of the unsexy work that makes everything downstream possible.

  2. 02 COMPONENT

    The teaching loop

    The runtime. It sits between the learner and the graph, and adapts on two axes simultaneously.

    • Path adaptation — what to teach next

      The loop's primary job. Given the learner's current state and goal, it chooses the next move — explain, exercise, push back to a prerequisite, or advance — and applies the policies that make that move trustworthy. Validation runs here. Evidence thresholds for advancement live here. Pacing, repetition, and remediation all live here. This is also where the deterministic guards sit: rules that decide when the model gets to suggest, and when the answer is settled by logic.

    • Content adaptation — how to teach it

      The same node can be taught many ways. An aviation engineer learning probability gets aviation examples; a doctor gets clinical ones. Hints, tone, and analogies adapt to the learner's vocabulary and prior knowledge. If the existing ingredients can't be adapted, the loop signals upstream — new ingredients are needed.

    Both axes share one trait: decisions live in the loop, not in the prompt. The prompt may phrase the explanation; the loop decides whether explanation is even the right move.

  3. 03 COMPONENT

    Learner state model

    What the system knows about this person and how it updates. Not chat history. An explicit, structured profile: what they have shown they understand, where they have struggled, how confident their evidence is, what their context and goals are.

    This is what the loop reads from and writes to. Get this wrong and every other component compounds the error.

Tension 01 · The split that matters most

Deterministic vs model-based

Keep the model out of decisions where correctness is settled by logic.

Engineers who ship reliable systems already know this split. Validation logic, advancement gates, and tenant boundaries are deterministic — they have to be. Explanation style, example selection, and conversational scaffolding are model-based — that's where flexibility creates leverage.

The discipline is keeping the model out of decisions where correctness matters and using it heavily where semantic flexibility is the value. Bolt-on systems get this wrong by letting the model improvise both.

This split matters more in education than in most domains. A hallucinated explanation can break a learner's understanding silently — and the failure shows up downstream, when something built on top of that misunderstanding breaks. Evidence gates — the rules that decide whether a learner has earned advancement — are the place where deterministic logic is non-negotiable. The model can phrase the question. It must not be allowed to settle the answer. And every gate decision should be observable, so when something goes wrong, you can find where.

This is also where most of the engineering effort actually goes. Manual review is too slow to keep up with generated content. Catching errors after they reach learners is too expensive. So the real work is building cheap, fast validation — automated checks that catch wrong content before it ships, observability that surfaces drift early, and tight feedback loops that let the system improve from each catch. It is its own discipline, and it's where serious teams will spend most of their time.

Tension 02 · The real failure mode

Advancing without mastery

The hardest failure looks like success.

The pattern is simple to describe and hard to detect: a path that is coherent-looking but pedagogically wrong. A learner solves a problem after three hints, and the system advances them. They guess correctly, and the system advances them. Months later, the gap surfaces in a downstream skill that depended on real understanding.

Engines that work treat correctness as a signal, not a verdict. They qualify how that answer was produced — independent or scaffolded, fast or hesitant, transferred or memorized — and only update the learner state on evidence that earns it.

Where this leaves us Three components. Two axes of adaptation. One discipline about what the model decides and what it does not. That's the engine — and it's where the better products are heading. The classical engines built their adaptation around a fixed curriculum: pre-authored ingredients, stable skill graphs. That assumption is breaking. Skills now appear faster than curricula can be written, and a learner's existing knowledge is a moving target. This is where LLMs stop being a feature and start becoming the animating force inside an engine that already knows how to adapt. What does that end up being for? That's where I want to land.

Direction

Where this is going

And here we come back to where I started. I went looking at online courses because I needed a specific skill, and I needed it fast. Not a diploma. Not a year of study. A specific gap, the kind that was blocking me from moving forward.

I closed the gap. But I had to push through things I already knew, through irrelevant explanations, through examples that had nothing to do with what I actually do. Eight hours for what could have taken two. Three cases like that in recent months — and I started seeing the pattern. Not from theory. From the friction itself, and from what's becoming possible underneath it.

What convergence opens up

Classical engines plus LLM as the animating force opens three things that weren't there before.

  • 01The curriculum stops being static

    Old engines adapted inside a fixed curriculum: pre-authored ingredients, stable skill graphs. LLMs let the engine generate ingredients on demand, for a skill that didn't exist in the course yesterday. The authoring cycle no longer has to block every adaptation step — though humans still own the skeleton: the skill graph, the key dependencies, the pedagogical structure. LLMs fill the spaces inside that structure; humans review what they fill. Over time the boundary moves, but for now the skeleton stays human, and the validation does too.

  • 02The starting point is the learner, not the curriculum

    The engine no longer assumes the learner enters at the beginning of the course. It meets them where they are — with their existing knowledge, their context, their language. "Shortest path through the gaps" stops being a marketing line and becomes a real operation.

  • 03Learning stops being a separate destination

    This is the biggest shift, and it's only beginning to surface.

The embedded shift

When the engine can adapt without a fixed curriculum, "going to a course" stops being the only interface for learning. Learning can meet you in the middle of the work. A concept gap surfaces in a real task — the engine notices, delivers exactly the unit that closes the gap, and you keep moving. Not a separate session. Not "block out an hour to learn." Inside the work loop itself.

An honest note about where this gets useful, not just where it gets futuristic. Most of what we call embedded learning today is still AI chat inside a learning product. The bigger version is different — an agent that travels with the work itself, holds the learner's skill graph, and turns moments of doing into moments of learning. This is where corporate learning could become meaningfully more effective, instead of being a budget line everyone tolerates.

An IDE extension that teaches an engineer a new framework as they write in their actual codebase, not in a tutorial sandbox. An agent that walks an operations manager through configuring a real workflow as they configure it — turning the configuration itself into the lesson. A system that watches sales calls with consent, spots the specific gap that lost the deal, and delivers a targeted 90-second lesson before the next call.

Not learning detached from life and loaded in like a Matrix download — learning as part of it. Built in small enough pieces, adapted to what you're actually doing, in the part of the workflow where the risk of getting it wrong is contained. That requires the engine plus a runtime that sees your context. The first exists. The second is barely beginning.

Courses don't disappear. They just stop being the only place where adaptation lives.

Closing

We learn every day. The difference is how efficiently. The frontier of what's possible is shifting in one specific direction right now — toward how densely and how fast you can compress experience for a specific person and deliver it exactly where it will be used immediately.

The scenario where AI turns us into a lazier version of ourselves, and the scenario where it opens new ranges — diverge right here, at the same fork. An engine that teaches without standing in for the thinking is the middle path.

The right marker isn't comfort — it's tension. Effort should be felt. Too little, and nothing is moving. Too much, and the learner gets thrown. A working engine doesn't take the tension away — it calibrates it: right skill, right pace, right place to push. The goal is not to remove effort. The goal is to stop wasting effort on the wrong material.

We're not loading skills like in The Matrix — not literally. But we can compress and adapt how we acquire them, sharply. The engine adapts to the learner — language, pace, existing knowledge — and fills only what's actually missing. That's the difference between knowing something and being able to do it.

And it is, for the first time, buildable.

Sources & notes

Sources & notes

This essay uses a qualitative market map, not a benchmark. Player positions and category placements are approximate, based on public evidence of: learner-state modeling, skill or concept representation, assessment loops, runtime adaptation, AI-assisted instruction design, and the degree to which AI sits inside the learning loop rather than beside it. Sources were checked for public positioning and product descriptions available around 2025–2026; product capabilities may change after publication.

  1. ALEKS / McGraw Hill. ALEKS is built on Knowledge Space Theory and describes its adaptive assessment as placing a learner within large knowledge spaces — full Algebra 1 covers a few trillion feasible knowledge states. This supports the claim that ALEKS is a mature classical adaptive engine, not a sidecar.
    aleks.com/about_aleks/research_behind
  2. Carnegie Learning / MATHia. Carnegie Learning describes MATHia as intelligent math software that adjusts to each student action, providing real-time feedback and assessment. Supports placement in the classical ITS / adaptive engine group.
    carnegielearning.com/solutions/math/mathia
  3. Duolingo Birdbrain. Duolingo's research blog explains Birdbrain as a machine-learning model that estimates learner ability and exercise difficulty, predicting whether a learner will answer correctly and feeding that signal into lesson generation. Supports its classification as a modern ML-driven adaptive engine.
    blog.duolingo.com/learning-how-to-help-you-learn-introducing-birdbrain
  4. DataCamp. DataCamp's stated direction frames its AI-native learning as adaptive — described as "not an AI chatbot bolted onto existing content," with lessons, challenges, and examples adapting in real time around learner level, goals, context, and learning style. Supports inclusion as a convergence candidate; much of the technical detail remains proprietary.
    datacamp.com/blog
  5. DreamBox Math. DreamBox documents continuous assessment, dozens of in-lesson assessment points, next-best-lesson selection, and adaptation of lesson content based on prior responses. Supports placement among real adaptive engines.
    dreamboxlearning.zendesk.com/hc/en-us/articles/27281596241043
  6. IXL Real-Time Diagnostic. IXL describes ongoing diagnostic assessment, up-to-date portraits of student knowledge, and personalized action plans linked to specific skills. Supports its placement as diagnostic / adaptive practice infrastructure.
    ixl.com/membership/administrators/real-time-diagnostic
  7. Area9 Rhapsode. Area9 describes Rhapsode LEARNER as an adaptive learning product that guides learners step-by-step toward proficiency. Public architectural detail is less explicit than ALEKS or Birdbrain, but the system is squarely in the adaptive engine group.
    help.area9lyceum.com/higher-education/area9-rhapsode-learner-overview
  8. Eedi. Eedi publicly describes constrained AI tutoring built around diagnostic signals, RCTs run with Google DeepMind, and classroom learning-outcome measurement. One of the strongest public evidence trails among newer AI-tutor entrants.
    eedi.com/news/just-launched---our-second-ai-tutor-rct
  9. Knewton Alta / Wiley. Wiley describes Alta as mastery-based adaptive courseware that continuously diagnoses and adapts to student proficiency, provides just-in-time instruction, and remediates prerequisite gaps.
    wiley.com/education/alta
  10. Coursera Coach. Coursera describes Coach as a GenAI learning assistant with contextual understanding of course content and tailored learner support. Supports classifying it as a learner-support layer beside existing course structure.
    blog.coursera.org/coursera-coach-leveraging-genai-to-empower-learners
  11. Codecademy AI features. Codecademy's AI Learning Assistant understands the current course, instructions, and solution code to provide feedback and guidance. AI Builder also creates personalized project-based learning paths — a stronger edge case between assistant, authoring, and orchestration.
    help.codecademy.com/hc/en-us/articles/23400751016859
  12. LinkedIn Learning AI-powered Coaching. LinkedIn describes AI coaching as helping learners navigate the content library, get personalized advice, practice roleplays, and receive course recommendations. Supports placing it in AI coaching / skill-path orchestration rather than adaptive delivery runtime.
    linkedin.com/products/linkedin-learning-aipowered-coaching
  13. Khanmigo / Khan Academy. Khan Academy describes Khanmigo as an AI-powered teaching assistant and tutor, with tools such as Writing Coach and teacher-facing recommendations. Important AI learning features; public materials don't establish a full delivery-loop engine.
    khanacademy.org/khan-labs
  14. Quizlet. Quizlet launched Q-Chat as a ChatGPT-powered tutor, then discontinued it in June 2025; current AI study tools focus on practice tests, study guides, flashcard generation, summaries. Supports treating Quizlet primarily as AI study tooling / sidecar.
    quizlet.com/blog/meet-q-chat
  15. Memrise. Memrise describes MemBot as a personalized AI language tutor / language partner, with speaking practice and videos matched to learner level and interests. Conversational language practice plus personalization, not a full adaptive progression engine.
    memrise.com
  16. Pearson AI-Powered Study Tools. Pearson describes its AI study tools as GenAI chat support embedded inside eTextbooks/courses, drawing from Pearson content to provide individualized support, practice, and feedback. Course-side assistance, not proven delivery-loop adaptation.
    help.pearsoncmg.com/etextbook/student/en-us/Content/Topics/ai_study_tools_etext.htm
  17. Google LearnLM. LearnLM is described as a family of education-tuned models built on Gemini, used across Google products. Important as model infrastructure for learning experiences; not, by itself, evidence of a complete adaptive learning runtime.
    techcrunch.com/2024/05/14/learnlm-is-googles-new-family-of-ai-models-for-education
  18. Squirrel AI. A Guardian profile describes Squirrel AI's adaptive tutoring approach around small learning "nuggets," detailed learner-interaction tracking, and recommendations based on learner data at scale. Much of the public evidence is reported or company-claimed rather than independently documented — ambitious, but less independently transparent than ALEKS or MATHia.
    theguardian.com/technology/2020/mar/19/can-computers-ever-replace-the-classroom