Meno: An AI Tutor That Verifies Learning
Inspiration
Most AI tutors are good at explaining. But explaining is not the same as learning.
A learner asks a question, gets a clear answer, and the conversation moves on. The AI almost never checks:
- Did the learner really understand?
- Can they handle a slightly different case?
- Can they use the idea independently?
A good human teacher works differently. They first discover what the learner already knows. If the learner struggles, they change the explanation. They test the same idea in a new context, ask the learner to teach it back, and revisit it days later.
The name Meno comes from Plato’s dialogue Meno, in which Socrates teaches a boy geometry—not by lecturing, but by asking questions until the boy works out the answer himself.
That is how Meno teaches.
AI tutors explain. Meno makes sure you master it.
What Meno Does
Meno turns the learner’s own NotebookLM material into a structured, interactive course.
The learner adds a book, course, paper, video, or collection of sources to NotebookLM. They then open Meno in Codex or Claude Code and provide the notebook ID.
From there, Meno runs the complete learning workflow:
NotebookLM sources
↓
Source-grounded content analysis
↓
Small teaching modules in prerequisite order
↓
Course-specific mastery criteria
↓
Adaptive teaching through MasteryLoop
↓
Local learning memory
↓
Spaced retrieval reviews
Meno does not generate one large summary. It decomposes the material into focused modules, ordered so that each module builds on the knowledge required before it.
Every module receives its own mastery checklist with five kinds of observable evidence:
- Accuracy — Can the learner explain the mechanism correctly?
- Variation — Can they handle a changed case or counterexample?
- Feynman — Can they explain it simply, as if teaching a 10-year-old?
- Transfer — Can they apply it to a real situation?
- Communication — Can they summarize it in three clear, jargon-free sentences?
A score alone is not enough. Meno marks a module as mastered only when all five forms of evidence have been demonstrated.
The MasteryLoop
Meno teaches through a continuous feedback loop:
Probe
↓
Socratic questions
↓
Pressure test
↓
Misconception remediation
↓
Feynman explanation
↓
Real-world transfer
↓
Three-sentence communication
↓
Mastery and spaced review
Meno never begins with a lecture. It starts with a diagnostic question to discover the learner’s current mental model.
A real interaction might look like this:
Meno:
Before we start, why does a neural network need an
activation function?
Learner:
To make the output fall between 0 and 1?
Meno:
That is what one specific activation function does,
but it is not the fundamental reason.
What happens if you stack three linear layers with
nothing between them?
Learner:
You get... a larger linear layer?
Meno:
Exactly. Those linear layers collapse into one.
So what does the activation function add?
Learner:
It breaks the linearity, allowing the network to
learn curves and more complex patterns.
Meno:
Correct. You initially mixed up “activation function”
with “sigmoid.” I have saved that misconception, and
we will test it again later in a different context.
When the learner gives an incorrect answer, Meno records the specific misconception, changes its teaching strategy, and tries again.
Wrong answers never block the learner. Saying “I understand” is also not accepted as proof—the learner must demonstrate understanding.
After mastery, Meno schedules retrieval reviews after 1, 3, 7, 14, and 30 days, helping the knowledge remain accessible instead of fading after the session.
How I Built It
Meno is deliberately lightweight. It has no custom frontend and no large application stack. The repository itself is the agent workspace, running directly inside Codex or Claude Code.
The system has three main layers:
1. NotebookLM Grounding
Meno reads and queries the learner’s existing NotebookLM notebook. NotebookLM handles the source-grounded analysis, while the original material remains in the learner’s notebook and is never redistributed by Meno.
2. Agent Skills
Markdown-based skill files define how the agent should:
- Analyze different types of learning material
- Decompose sources into teaching modules
- Run the MasteryLoop
- Diagnose and remediate misconceptions
- Conduct spaced retrieval reviews
3. Deterministic Local Tools
Small Python tools:
- Validate generated teaching packages
- Register private local courses
- Enforce the five-part mastery gate
- Save learner responses and progress
- Schedule future retrieval reviews
The mastery gate is enforced by deterministic code rather than model intuition. All five evidence categories must contain concrete learner evidence before mastery can be granted.
Persistent Learning Memory
Each learner’s state is stored locally in three files:
state/<learner-id>/
├── memory.json
├── Progress.md
└── review_schedule.json
Together, these files store:
- Misconceptions discovered during learning
- Explanations and analogies that worked
- Mastery evidence collected so far
- Current course, module, and learning phase
- The next teaching action
- Upcoming review dates
Meno creates the learner state before asking the first diagnostic question and updates it after every response.
The learner can close Codex or Claude Code and return later by saying:
Continue where I left off.
Meno resumes from the exact course, module, phase, and next action.
Generated course content and personal learning records stay local and are excluded from Git by default.
Challenges I Faced
Turning Arbitrary Material into Teachable Structure
Different sources have different shapes.
A course contains modules and dependencies. A book develops a linear argument. A video may repeat itself, include conversational filler, or make claims without providing supporting evidence.
I created separate analysis paths for each content type while requiring them all to produce the same downstream contract:
- Structured teaching modules
- Prerequisite order
- Source grounding
- Course-specific mastery criteria
Preventing the AI from Teaching Things the Source Never Said
A language model can easily generate a convincing explanation that goes beyond the supplied material.
Meno grounds its analysis through NotebookLM and explicitly records evidence limitations. If the source does not support a claim, provide timestamps, or include the underlying research, Meno must say so instead of inventing precision.
Defining Mastery as Behavior, Not Feeling
“Do you understand?” is not a useful evaluation method.
The hardest design decision was turning mastery into observable learner behavior. This became the five evidence categories, combined with a deterministic gate that prevents the model from declaring mastery simply because the conversation appeared successful.
Making Learning Memory Reliable
A tutor that forgets the learner between sessions loses most of its value.
I built atomic local state persistence with recoverable transactions and per-learner locking. This prevents concurrent Codex and Claude Code sessions from silently overwriting the same learning history.
What I Learned
A good teaching agent needs more than a capable language model.
It needs:
- A consistent teaching protocol
- Grounded source material
- Explicit evaluation criteria
- Persistent learner memory
- A reliable definition of mastery
I also learned what personalization really means.
Personalization is not simply changing the tone or difficulty of an explanation. It means remembering a learner’s specific misconceptions, identifying which explanations worked for them, and choosing the next teaching action based on evidence.
What’s Next for Meno
Shareable course packages — Allow one person’s analyzed course structure to be reused by other learners while keeping progress separate. A local progress dashboard — Visualize mastery evidence, active modules, and upcoming reviews from the local state files. Study-group support — Teach multiple learners from the same material while tracking each learner’s evidence and misconceptions independently.
What Makes Meno Different
Most AI tutors have a trust problem: the learner says “I understand,” and the tutor believes them.
Meno begins with the opposite assumption:
Self-reported understanding is not evidence of mastery.
Meno is not a chatbot with a course interface. It is a portable teaching protocol that turns the learner’s own material into an adaptive course, works across languages, remembers the learner between sessions, and only accepts mastery that can be demonstrated.
Meno does not stop when the answer is delivered. It stops when the learner can use the knowledge independently—and returns later to make sure it lasts.
Log in or sign up for Devpost to join the conversation.