If you've spent any time in 2026 evaluating "AI for the classroom," you've probably noticed a strange thing: almost every product uses the same handful of words, personalized, AI-powered, adaptive, to describe two genuinely different pieces of software. It's worth pulling them apart, because they solve different problems, and picking the wrong one for your classroom wastes both your time and your students'.
The two shapes of "AI in the classroom" today
Look past the marketing copy and most AI-in-education products fall into a small number of shapes.
Teacher copilots generate things for you to use later. Tools like MagicSchool AI and Eduaide.AI sit in this category: you give them a topic or a standard, they hand back a worksheet, a rubric, a set of discussion questions, a differentiated reading passage. MagicSchool markets itself as an "AI operating system for schools" with dozens of single-purpose generation tools; Eduaide frames its output as pedagogy-grounded, built on an instructional-strategy knowledge graph. Diffit narrows the wedge further, one job, done well: take any text and rewrite it at multiple reading levels. What all of these share is the handoff point: the AI's job ends when the document is generated. You still open it, print it or project it, and teach it yourself, live, in front of the room.
AI tutors talk to one student at a time. Khan Academy's Khanmigo is the best-known example, a Socratic conversational tutor that's deliberately built not to just hand a student the answer, plus a separate assistant surface for teachers. It's a genuinely different shape of product: the "classroom" it optimizes for is one learner and a chat window, whether that's during independent work time, homework, or a lab. Duolingo and similar apps sit in an adjacent but distinct bucket, self-directed, gamified, 1:1 practice, not classroom delivery software at all.
Then there's a third shape that gets conflated with both of the above: live classroom engagement tools. Curipod, Nearpod, Kahoot!, and Quizizz put content in front of the whole class at once, polls, quiz rounds, response collection, which looks superficially like "whole-class AI teaching." Curipod is the closest existing analogue to what we build, worth naming directly: one prompt builds an interactive lesson delivered live to the whole room, and it validates that the whole-class wedge is real. But it's teacher-driven slide-by-slide, without an autonomous instructional runtime, pre-authored AI narration, or a connected per-student mastery system underneath it. Kahoot and Quizizz are quiz-format engagement layers, not authoring-and-delivery platforms, and teachers report the game-show format loses novelty with repeated use. None of these four run an AI-directed sequence through an actual lesson arc, objectives, worked examples, checks, closure, with a persistent runtime state and a full record of what happened.
(This is a scan of roughly a dozen named products across these categories, a useful map, not an exhaustive census of every classroom tool on the market.)
teloriva built the second thing this whitespace is missing: a whole-class AI-narrated runtime the teacher directs, not a document generator and not a per-student chat window.
Why whole-class delivery matters when most classrooms don't have student devices
Here's the practical problem underneath the category confusion: a huge share of real classrooms don't have a 1:1 device model. One projector, one teacher, twenty-five to thirty-five students, no laptops or tablets in front of every desk. In that room, a chat-based AI tutor has nowhere to run, there's no device for each student to type into. A document generator helps you prepare before class, but once the bell rings, you're back to delivering the lesson yourself, unaided, the same way you always have.
Classroom Auto-Teach is built for that exact room. It runs from a single projector. No student devices are required at any point, every class response path is teacher-mediated: the teacher selects an answer on behalf of the room, runs a manual poll count, or uses webcam-based hand-counting for a vote. It's a genuinely different delivery shape from both the copilot category and the 1:1 tutor category, purpose-built for the classroom most schools actually have today.
How the runtime actually works, mechanically
This isn't a slide deck with a narrator bolted on. Underneath Classroom Auto-Teach is a real runtime state machine (ClassroomRuntimeEngine) that walks a class through a lesson stage by stage, built from 25 purpose-built classroom components, opening objectives, key-term introductions, worked examples, compare-and-contrast walkthroughs, think-pair-share prompts, class polls, exit checks, and more, each one a self-contained instructional move designed for a whole room, not a single learner. A lesson is authored once, in a studio, as a Course → Unit → Session → Stage hierarchy, and then plays back reliably every time it's run live.
The teacher never loses the wheel. A full command set, next_step, skip, take_over, repeat, slow_down/speed_up, emergency_stop, lets you override the sequence at any moment, and every single one of those overrides is logged to an audit trail. If you take over mid-lesson to answer an unplanned question, that's recorded. If you skip a section because the class already gets it, that's recorded too. The AI runs the lesson; you still run the room, and there's a record proving it.
The narration itself deserves an honest note, because it's the part most likely to be oversold elsewhere: by default, it isn't generated live, in the moment, while you're teaching. It's authored once by AI at publish time and cached, so what plays in class is instant, pre-recorded narration, not a model "thinking" in real time in front of your students, by default. That's a deliberate design choice: instructional delivery shouldn't be waiting on an API call mid-lesson. The live view itself updates over server-sent events, with a database-backed fallback that guarantees state stays in sync within seconds even across multiple server processes.
The honest evidence distinction
This is worth being precise about, because it's easy for an "AI knows your classroom" pitch to quietly overclaim. Classroom Auto-Teach only ever records class-level outcomes, got_it, partial, confused, for each stage of the lesson. It does not, and structurally cannot, fabricate an individual grade for any one student from a whole-class signal like a poll or a show of hands. That's a design principle, not a current limitation: reading the room accurately is a different job from grading a student, and conflating the two is exactly the kind of overclaim this category is prone to.
Real per-student mastery tracking does exist in the platform, it just lives in a separate system entirely, built for individual coursework rather than projector sessions, using an actual Bayesian Knowledge Tracing model. That's a different article. The point here is narrower: Classroom Auto-Teach's job is to run the room honestly, at class scale, and it's built to do exactly that and nothing more.
Two different products, two different jobs
None of this makes teacher copilots or AI tutors worse tools, they're solving real, different problems. A copilot saves you prep time before class. A tutor gives one student a patient conversational partner during independent work. What neither does is stand in front of the whole room and run the lesson while you watch the students instead of the slides. That's the gap Classroom Auto-Teach is built to fill, an AI-directed runtime for the classroom you actually have, one projector and all, with you holding full control the entire time.
Want to see it walk through an actual lesson stage by stage? Explore Classroom Auto-Teach, teloriva's whole-class AI runtime →
For more on the honest boundary between what this runtime records and what it deliberately doesn't, see Class-Level Evidence vs. Surveillance.
Meta title: Teacher Copilot vs. AI Tutor: Two Different Products | teloriva Meta description: Most "AI classroom" tools are document generators or 1:1 chat tutors. Here's the whole-class AI runtime that's neither, and why it matters.