What MIND 2.0 is
MIND 2.0 is the AI layer sitting inside an online learning platform. It does three things:
- Tutors students against the material they’re actually enrolled in — not a generic model pretending to know the syllabus.
- Adapts pacing and recommendations based on how the student is performing, where they’re stuck, and what they’ve already covered.
- Stays grounded by retrieving from a structured representation of the course content rather than relying on the model’s parametric memory.
It ships behind the product, so I’ll describe the shape of the system rather than the specifics.
The shape of the system
There are three loosely-coupled subsystems, and the interesting engineering is in the seams between them.
The retrieval layer — course material, lesson objectives, assessment items, and a knowledge graph that encodes prerequisite relationships between concepts. Vectors for semantic lookup, graph for structural reasoning. The graph is what lets the system answer “what should this student see next?” instead of just “what matches this query?”
The orchestration layer — LangGraph flows that route a student’s message to the right tool: tutoring, retrieval, clarification, escalation. State is explicit and inspectable. If a flow misbehaves, I can see which node decided what, with what context.
The evaluation layer — scored runs on frozen student traces, rubrics for tutoring quality, and regression tests that flag when a prompt or model change degrades known-good cases. This is the part that isn’t optional and almost never makes it into tutorials.
Decisions I’d defend
Knowledge graph over pure vector retrieval. A lot of RAG systems flatten everything into embeddings and hope cosine similarity surfaces the right chunk. For education that breaks: prerequisite structure is the point. You can’t recommend what comes next if you don’t model what came before.
LangGraph over ad-hoc orchestration. The temptation with agentic systems is to wire flows together with imperative code and call it a day. That works until you need to debug why a session went sideways at 2am. Explicit state machines are worth the ceremony.
Evaluation before features. I don’t ship a new tutoring behaviour until there’s a rubric and a frozen test set I can run it against. It’s slower up front and much faster once the system is real.
What this taught me
Building this is the engineering problem I think about most. Not because the model calls are hard — they aren’t — but because the system around the model has to be correct in ways the model cannot be. Every assumption you offload to the LLM is one you’ve quietly said you’re fine not verifying.
The other thing: infrastructure realities shape design more than architecture diagrams admit. Latency budgets, network instability, cost-per-token at scale — these constrain which retrieval strategies are even on the table. Tutorials don’t talk about that. The job does.