What It Actually Takes to Build an AI Tutor You Can Trust
AI in education gets discussed as either a replacement for teachers or a cheating machine. The actual question worth asking is narrower and more useful: what makes one trustworthy?
AI in education tends to get discussed at two extremes, either as something about to replace teachers, or as a glorified way to cheat on homework. Both framings skip past the actual engineering question, which is narrower and more useful: what would it actually take to build an AI tutor a parent, a teacher, or a student could genuinely trust to teach and grade correctly? We built a real tutoring system to find out, and the answer turned out to be less about the model and almost entirely about the discipline built around it.
Why the stakes are different here than almost anywhere else
A wrong AI answer in most contexts is a minor annoyance, a bad restaurant suggestion, a slightly off marketing idea someone catches and discards. A wrong answer from a tutor is a different category of problem entirely, because the person receiving it usually has no way to tell it's wrong. That's the entire premise of needing a tutor in the first place: the student doesn't yet know the material well enough to catch a plausible-sounding mistake. A confidently wrong method, taught fluently and reinforced through practice, doesn't just fail to help, it actively teaches something false and leaves the student more confident in it than if they'd never asked.
The core failure mode: teaching from memory instead of the syllabus
A general-purpose model asked to tutor a specific curriculum will answer from its training data by default, whatever formulas, methods, and worked examples it absorbed in general, not necessarily the specific version a given syllabus, exam board, or textbook actually teaches. That mismatch is subtle and genuinely dangerous: the model isn't lying, it's answering honestly from what it knows, which simply isn't guaranteed to match what the student is actually being assessed on. The fix isn't a smarter model. It's refusing to let the model answer from memory at all when a real, checkable source exists.
What grounding actually looks like, concretely
We built exactly that discipline into a real tutoring Skill on our own AI harness, which we've written up in full detail separately. The short version: before teaching any topic, it's structurally required to look up the real syllabus unit's teaching notes rather than answer from its own general knowledge. Before grading any student's answer, it's separately required to fetch the actual worked solution for that specific question and grade against it, never against a solution it reconstructed from memory. Two distinct lookups, two distinct moments where the system is forced to check something real before it's allowed to speak with any authority.
Grading is still a judgment call, just an accountable one
It's worth being precise here, because the honest answer isn't "the AI never makes a judgment," it's "the AI's judgment is always checkable against something real." The model still decides whether a student's free-form answer matches the correct method, recognizing a right approach expressed in different words, or spotting exactly where reasoning diverged, which genuinely needs language understanding a rigid answer-key match wouldn't have. What the grounding buys isn't the removal of judgment, it's that the judgment is always being made against a real, stored solution, not an invented one, and that solution is something a teacher or parent could independently pull up and check the grading against.
Why memory matters more in tutoring than in most AI use cases
A tutor that starts every session from zero, no memory of what a student has already struggled with, is missing something a genuinely good human tutor would never miss: the specific pattern in how this particular student gets things wrong. Our tutoring Skill is built to notice a recurring mistake, reaching for the wrong formula in a certain kind of problem, say, and save that specific pattern so a future session on a related topic starts already aware of it, rather than re-teaching generically every single time. That's a meaningfully different experience from a tutor that's technically always available but functionally has amnesia between sessions, and it's the difference between AI tutoring feeling like a real, ongoing relationship with a student's actual learning versus a slightly-better-than-average search engine wearing a friendly tone.
Where a human still needs to be in the loop
Grounding solves the accuracy problem. It doesn't, on its own, solve the accountability problem, and we don't think it should try to. Every graded attempt gets recorded against a specific student, building a real, checkable history rather than an ephemeral chat log nobody can review afterward. That auditability is the actual point: a parent or teacher should be able to look at what a student was taught and how an answer was graded, not just be told to trust that it went well. We've written more generally about why we run a similar self-monitoring pass over our own AI agents rather than assuming they're behaving correctly just because nothing crashed; the same principle applies here, doubled, because the audience is a student who can't yet judge the quality of what they're being taught.
What AI in education should not be
It's worth being direct about the boundary. An AI tutor that just hands over the final answer isn't tutoring, it's a shortcut to skipping the learning, and any tutoring Skill worth building should be explicitly instructed to teach the method, not just state a result. It also shouldn't be positioned as a replacement for a teacher's judgment about a student's overall progress, a curriculum decision, or anything requiring context beyond one subject and one syllabus unit. What it's genuinely good at is the narrow, well-scoped, repetitive part: patient, always-available practice on a specific topic, grounded in real material, with a memory of exactly where a specific student keeps getting stuck. That's a real, valuable niche. It's not the whole job.
A concrete moment where grounding actually shows its value
Picture a student working through a circuits problem who applies a formula that's correct for a similar but subtly different problem type, a mistake that's genuinely easy for a model to miss if it's grading from a general sense of the topic rather than the actual solution. Because the tutor is required to fetch the real worked solution before judging the answer, the mismatch is caught precisely, at the exact step where the wrong formula was applied, not just flagged as "incorrect" with no explanation of why. That specificity is only possible because the comparison is against something real. A tutor grading from its own general sense of the topic could easily have missed the same subtle error, or worse, agreed with it.
Why this is a harder problem than customer support or marketing
It's worth naming directly why we think education is a harder domain for AI than most of the business use cases we typically build for. A customer support agent that's slightly imprecise costs a slightly worse interaction, correctable the next time someone actually talks to a human. A tutor that's slightly imprecise costs a specific gap in what a student actually understands, compounding silently over weeks until it surfaces as a much larger problem at exam time, with no one along the way flagging that the foundation was ever shaky. That asymmetry between an easily-corrected mistake and a silently-compounding one is exactly why grounding isn't a nice-to-have feature here, it's the entire precondition for the tool being safe to use at all.
A practical checklist for evaluating any AI tutoring tool
- Does it cite or ground its teaching in real curriculum content, or could the exact same explanation have come from any generic AI chatbot with no syllabus awareness at all?
- Does it grade against a real, verifiable solution, or is it just generating a plausible-sounding verdict on the spot?
- Does it track a student's progress in a way a teacher or parent can actually review afterward, not just a private chat log?
- Does it remember a specific student's recurring weak spots across sessions, or does every conversation start from zero?
- If it isn't confident about something, does it say so, or does it answer with the same fluent confidence regardless of whether it actually knows?
That last question matters more than it might seem. A tutor's most dangerous failure mode isn't getting something wrong, it's getting something wrong with exactly the same tone of voice it uses when it's right, which is precisely why grounding it in real, checkable material rather than trusting its own fluency is the entire foundation everything else in this piece is built on.
None of this is a finished, solved category, and it's worth saying so plainly rather than overselling where things actually stand. Trustworthy AI in education is a genuinely young field, and the specific engineering discipline described here, grounding, auditability, persistent progress tracking, is our answer to the hardest part of the problem, not a claim that every question about AI in classrooms has been settled. What we're confident about is narrower and more defensible: an AI tutor that's structurally forbidden from teaching or grading from its own memory is meaningfully safer than one that isn't, and that's the bar worth insisting on before any AI tool gets anywhere near a real student's learning.