DeepTutor v1.5 and AideAI: Two Paths Toward Adaptive Learning

A polished answer is not the same thing as demonstrated understanding.

You can ask any AI chatbot to explain equilibrium, get a confident paragraph back, and still freeze when Friday's quiz asks you to predict what happens when you change concentration. The paragraph sounded complete. Your reasoning did not survive contact with the question.

That gap is why "AI tutor" and "AI chatbot" are not interchangeable labels — even when the chatbot uses a tutoring prompt. Tutoring is not a tone. It is a loop: ask, attempt, check evidence, decide what comes next, remember what actually held up.

After DeepTutor v1.5 was released, we studied DeepTutor — an open-source agent-native learning system from HKUDS (GitHub, preprint) — as a serious new reference point, not a competitor to dunk on. DeepTutor did not shape AideAI's original adaptive design: the two systems were developed independently. Comparing them after release is useful precisely because they arrived at several related principles from different starting points.

This is an opinionated architectural essay, not a feature checklist or a buyer guide. If you want the student-facing learning workflow first, read Use AI to Understand Class Material Faster, Not Just Generate Answers. If you want the semester context layer, read How to Finally See Everything Going On in Your Semester.

The Chatbot That Tutors Versus The Tutor That Remembers

Most "AI tutor" products are chatbots with a friendlier system prompt.

They can explain, simplify, and quiz. What they usually lack is durable learning state:

• Did you attempt the idea before seeing the solution?
• What evidence from that attempt was strong enough to count?
• Which objective should come next — and why?
• What should resurface three days later because you almost had it?

Without that state, every session starts at zero. The model may sound pedagogical. The product is still a conversation, not a tutor.

Real tutoring systems treat evidence as a first-class object. A strong attempt, a weak attempt, a near-miss explanation, and a transfer question that fails for a specific reason are not interchangeable chat turns. They are signals that should change what happens next.

That is the design line the comparison exposed in both systems, even though their adaptive-learning work developed independently.

What DeepTutor Gets Right

DeepTutor is worth studying because it treats learning as infrastructure, not as a single chat mode.

At a high level, it builds a universal agent-native learning OS around ideas that are easy to say and hard to ship:

• a shared chat runtime for guided study flows
• a deterministic mastery policy sitting beside model judgment
• PendingQuestion state so grading can refer to the same question and rubric across turns
• a question bank and review layer for resurfacing practice
• inspectable memory tiers (L1 / L2 / L3) instead of one opaque context blob
• course knowledge bases that accumulate material inside a learning workspace

The mastery scoring is deliberately simple and transparent — which is a feature, not a limitation. DeepTutor weights your most recent five attempts, applies caps when you only have one or two tries (so early luck does not look like mastery), uses a quantitative gate around 0.9 for structured items, and leans on LLM judgment for concept- and design-style questions where a numeric threshold alone would lie. That is an honest split: code owns the policy shape; the model owns the parts that need semantic judgment.

We are not treating a 90% bar as universal truth for every kind of learning evidence, and we are not repeating benchmark claims from the preprint as independent facts. Where the paper reports results, those are author-reported preprint outcomes — useful context for researchers, not a product scoreboard. What mattered more to us was the architecture: separate runtime, persistent question contracts, inspectable memory, and code-owned transitions between objectives.

DeepTutor's "one runtime" slogan is directionally right for guided tutoring, though not absolute — modules like Book and Co-Writer follow their own paths. That is fine. The lesson is still clear: learning flows benefit when the product owns session state instead of hoping the model improvises pedagogy from scratch every time.

Why AideAI Starts From A Different Place

AideAI is not trying to become a standalone learning OS you populate from zero.

It is building a contextual academic action layer on the Mac where student work already lives:

• Canvas and Google Classroom assignments, announcements, and materials
• deadlines and course health in Study overview
• PDFs, lecture notes, recordings, and local files as grounded context
• Plan, Learn, Write, and Agent Desk workflows tied to real coursework

The flagship adaptive flow today is a short, guided Adaptive Study Session launched from an eligible assignment's Adaptive prep CTA. The sequence is intentional and code-validated:

try → compare → explain → transfer

You attempt first. You see a contrasting case. You get an explanation tied to the gap the session surfaced. You face a transfer check that asks whether the idea travels to a nearby problem.

That is a different entry point than DeepTutor's workspace-first model. DeepTutor tends to become more powerful after you have invested in a learning workspace — knowledge bases, memory tiers, review queues, and a durable study environment you maintain inside the product.

AideAI is trying to help before that investment — and often before you write a prompt — because it can read academic context and timing from the semester you are already living:

• a quiz-type assignment due Friday
• assignment details already synced, with a lecture PDF available to attach when needed
• a course health signal that says this unit is stacking up
• a recommendation that this assignment is a good candidate for adaptive prep tonight

The most important product difference is not "whose prompt is nicer." It is when the system can act. DeepTutor rewards the student who builds a learning workspace. AideAI is optimized for the student who has a Canvas deadline and forty minutes before the library closes.

For the file-and-context layer that feeds those sessions, read Use PDFs, Notes, Docs, and Audio as Real AI Context.

The Shared Design Principle We Are Keeping

The clearest architectural convergence in this post-release comparison generalizes beyond either product:

The LLM should decide how to explain and how to ask. Code should decide what evidence is sufficient, what state to persist, and what objective comes next.

That separation sounds obvious until you watch products violate it in both directions:

• Model-owned policy — the chat improvises whether you are "ready to move on," so the same answer might pass or fail depending on phrasing luck.
• Code-owned pedagogy — rigid scripts pretend to teach complex concepts without listening to the student's actual misconception.

The workable middle is a contract. The model generates explanations, questions, contrasting cases, and rubric-aware judgments inside a schema the orchestrator understands. The orchestrator decides whether the session advances, retries, or ends with a modest outcome label.

In AideAI's current MVP, that shows up as deterministic recommendation rules for when Adaptive prep should appear, schema-validated step transitions, and analytics events that measure whether students actually move through the loop instead of just opening a chat.

Wednesday Night: A Quiz Due Friday

Picture a concrete student moment.

It is Wednesday, 8:40 p.m. You are in Intro Chemistry. Friday brings a quiz on equilibrium and Le Chatelier's principle. Canvas shows the assignment. Your lecture PDF is in the course files. You took notes, but the practice problem still feels fuzzy.

Generic chat path: you paste "explain Le Chatelier." You get a clean summary. You feel briefly smarter. You cannot solve the practice set without rereading the summary like a script. On Friday, you recognize the vocabulary but cannot predict the direction of shift when temperature changes.

Workspace-first tutoring path: you open your learning environment, attach the unit, seed a knowledge base, and start a guided loop. Powerful — if you already built the workspace and know this is the tool you are supposed to use tonight.

AideAI path today: Study overview already shows the quiz assignment and course pressure. On the assignment card, Adaptive prep is available because recommendation rules flagged it as a good fit. You tap it. Learn mode opens with the assignment, course, deadline, and synced description as structured context; you can attach the lecture PDF separately when it matters. The session asks you to try a prediction first, shows a contrasting case where two students reason differently, explains only the gap it observed, then runs a transfer check on a nearby scenario.

You discover you were treating a concentration change like a pressure change. The session ends with a modest outcome — not "mastery achieved," but evidence that you corrected a specific confusion before Friday.

That is the tradeoff we are optimizing for: less setup than a full learning OS, more structure than a chat prompt, grounded in the assignment you already need to do.

What The Comparison Validates — And What We Would Not Copy

DeepTutor provides useful external validation for several directions already present in AideAI's roadmap, while also highlighting choices that should remain product-specific.

The comparison validates:

• Persistent question contracts — PendingQuestion-style state so grading refers to the same rubric across turns and restarts.
• Inspectable review history — a question bank you can trust because entries are tied to evidence, not just chat vibes.
• Code-owned next-objective policy — an Objective Map that decides what comes next after enough evidence exists.
• Honest outcome labels — statuses like demonstrated, not theatrical "mastered" badges backed by one lucky attempt.
• Layered memory — lightweight learning records that stay separate from LMS snapshots so academic sync does not corrupt learning evidence.

We will not copy blindly:

• a universal 90% gate as the default truth for every knowledge type
• weak open/fuzzy grading without a reproducible rubric contract
• black-box mastery claims that students cannot inspect or question
• a workspace-only entry point that ignores Canvas deadlines and Mac-native academic context
• benchmark marketing that treats preprint author reports as product proof

DeepTutor earned respect by making many of these tradeoffs explicit in code. The overlap is not evidence that one product derived its design from the other; it is evidence that serious adaptive-learning systems repeatedly encounter the same state, evidence, and progression problems.

What Is Live In AideAI Today — And What Comes Next

We would rather under-promise than dress up a chat feature as a full mastery engine.

Implemented in the current adaptive learning MVP:

• assignment-level Adaptive prep CTA on eligible Study assignments
• deterministic recommendation rules for when that CTA should surface
• guided try → compare → explain → transfer flow with schema validation and retry/fallback handling
• scoped learning memory that recalls the last three learning records when bootstrapping a new session
• nine analytics events across the adaptive funnel so we can see where students advance or stall

Planned — not shipped yet:

• Study Home recommendation card (Phase 5) for next-best study action on Overview
• hardening work such as abandonment tracking, kill switches, and localization QA (Phase 6)
• PendingQuestion / Question Bank foundation for reproducible grading across turns
• Evidence Model for attempts, rubric confidence, and knowledge-type tagging
• Objective Map / next-objective policy owned by code, not prompt improvisation
• spaced review once evidence is worth resurfacing
• dedicated course-centric knowledge base separate from general chat context
• longitudinal mastery tracking only after enough inspectable evidence exists

AideAI does not yet offer a full mastery model, spaced repetition system, or dedicated course knowledge base in the DeepTutor sense. If a product page ever implies that, it is ahead of the code. The current adaptive session is a focused loop meant to make strategy-aware learning visible on real assignments — not a claim that we finished the entire learning engine.

From Answers To Evidence

The market keeps selling "AI tutors" that are still generic chatbots with study-themed prompts.

DeepTutor shows what happens when you take tutoring seriously as systems design: shared runtime, persistent questions, inspectable memory, deterministic policy, and course-scoped knowledge that compounds over time.

AideAI independently approaches the same class of problems from a different entry point: a native Mac assistant that already knows your assignments, deadlines, and materials, and can run a short guided session when the semester — not a blank prompt box — tells you what matters tonight.

If you want to see that loop on real coursework, download AideAI and open Adaptive prep on an eligible assignment in Study. Compare plans on Pricing when you are ready for Premium models and voice features. And if you are still separating "fast answers" from "actual understanding," start with Use AI to Understand Class Material Faster, Not Just Generate Answers — the pillar post this adaptive work extends, not replaces.