DeepTutor: An Agent Shipping a New Version Every Two Days, Turning Tutoring Into Infrastructure
From "Tutoring" to "Lifelong Tutoring"
Traditional tutoring has a fatal flaw: the tutor doesn't remember you.
Every session, a human tutor spends ten minutes reviewing what was covered last time. If you switch tutors, everything starts from zero. If the tutor gets sick, your learning stops.
AI tutors solved the "remembering" problem—conversation history can be saved. But new problems quickly emerged: conversation histories get too long for models to fully recall; conversation history is linear, but learning isn't; conversation history is text, but learning needs practice, quizzes, and visualization.
What DeepTutor wants to do: turn tutoring from a one-time service into lifelong infrastructure.
What Does a Release Every Two Days Mean?
DeepTutor's GitHub releases page is striking: v1.6.15 released October 19, v1.6.14 on October 16, v1.6.13 on October 14. A new version every 2-3 days, sustained for two months.
This is not a demo project. It's a product iterating at high speed.
A release every two days means the team isn't just "building features"—it's "responding to users." Each release fixed something concrete: v1.6.15 improved the outline-change review flow in Guided Learning, v1.6.14 added independently scored question groups, v1.6.13 added bounded tutoring memory.
This pace of iteration implies real users. Without user feedback, it's impossible to precisely fix one thing every two days.
Folders as Learning Workspaces
DeepTutor's core concept is folder-based learning workspaces.
You create a folder called "Machine Learning" and throw in PDFs, notes, and code. DeepTutor will:
- Build a knowledge base from those materials (RAG index)
- Generate a question bank based on the materials
- Generate a mastery path based on your level of mastery
- Push daily practice to you
- Be polluted by early misinformation (you misunderstood at the start, and it keeps assuming you don't understand)
- Suffer attention dilution from overly long context (remembering everything equals remembering nothing)
- Fail to adapt to your progress (you didn't get something three months ago, you do now, but the tutor is still teaching basics)
- Reading with citations
- Question bank
- Daily practice
- Learning journal
- Mastery paths
- Knowledge bases
- Folder workspaces
- Multi-provider
- Bounded memory
The key to this design isn't RAG—anyone can do RAG. The key is folder as workspace.
Traditional AI tutoring is "you ask, I answer"—you ask a question, it answers, done. DeepTutor is "you give me materials, I help you learn"—materials are the input, mastery is the output. The former is chat; the latter is a workspace.
This is the same logic as OpenBot: an Agent doesn't need a bigger context window—it needs a more persistent working environment. DeepTutor gives the learning agent a folder; OpenBot gives a general agent a desktop.
"Bounded Tutoring Memory": More Memory Isn't Always Better
v1.6.13 added a feature called bounded tutoring memory.
This feature deserves attention. "Bounded" means limited—DeepTutor actively caps the size of the tutor's memory.
Why? Because more memory isn't necessarily better.
A tutor that remembers everything you've ever said will:
DeepTutor's bounded memory is an active forgetting mechanism. It's not "remember everything," it's "remember what matters." Just like a good human tutor: it doesn't memorize every sentence you say, but it remembers your key misconceptions, key breakthroughs, and key habits.
This aligns with the insight from the 10/16 piece "Scaling Discovery Requires Forgetting": memory isn't neutral storage—it's a conditioning prior that systematically narrows the search space. DeepTutor actively limits memory so past understanding doesn't constrain future learning.
"Mastery Path": Learning Isn't Q&A, It's a Path
Another core concept is the mastery path.
Traditional AI tutoring is Q&A-style: you ask, it answers. What you ask determines what you learn.
DeepTutor flips this: it generates a mastery path from your materials—what to learn first, what next, what level each stage requires. You don't need to know what to ask; DeepTutor tells you what to learn.
It's more like school, but more personalized. A school's path is for everyone; DeepTutor's path is generated from your materials, your answers, your level of mastery.
The mastery path solves the "not knowing what you don't know" problem. Q&A tutoring can only answer questions you know to ask; a mastery path can surface what you didn't know you didn't know.
Multi-Provider Isn't a Gimmick
DeepTutor supports Gemini, Codex, OpenAI, Anthropic, xAI, DeepSeek, and Ollama.
This isn't "we support every model" marketing. It has practical meaning:
Different models excel at different things. Gemini is strong at long context (good for long PDFs), Codex is strong at code (good for programming study), Claude is strong at reasoning (good for math), GPT is strong at general knowledge (good for multidisciplinary work).
DeepTutor lets you pick different models for different tasks—Gemini for reading materials, Claude for question generation, GPT for grading. Not technical showing-off, but engineering pragmatism.
From "Tutor" to "Learning Operating System"
DeepTutor's feature list reads less like a tutoring app and more like a learning operating system:
Traditional tutoring does one thing: answer questions. DeepTutor does five: organize materials, generate paths, create practice, track mastery, manage memory. The first is what chat can do; the other four require infrastructure.
DeepTutor's real value isn't the AI tutor—it's learning infrastructure. The AI tutor is the entry point; learning infrastructure is the moat.
HKUDS: An Academic Team Doing Engineering
DeepTutor comes from HKUDS (the University of Hong Kong's data science lab). It's a product from an academic team, but it iterates like a startup.
Academic teams building products usually fall into two extremes: paper-oriented—publish and abandon, leaving code to rot on GitHub; or product-oriented—continuous iteration, but diluted academic value.
DeepTutor seems to have found a middle path. It has a paper (arXiv:2604.26962) and a release every two days. The paper defines the method (agentic personalized tutoring); the product implements it.
This model is worth noting: academic teams don't have to choose "paper or product"—they can choose "paper + product". The paper certifies the method; the product validates it. DeepTutor's two-day release cadence is the method being continuously validated against real users.
What "Lifelong Learning" Really Means
"Lifelong Personalized Tutoring."
The point of this slogan isn't "tutoring"—it's "lifelong."
What does lifelong mean? It means the tutor accompanies you from middle school to high school to university to work. It means the tutor must remember how you learned ten years ago while adapting to your current needs. It means tutoring can't be a one-off—it must be a continuous service.
DeepTutor's bounded memory, mastery paths, and folder workspaces all exist to serve "lifelong." A one-time tutor doesn't need memory management; a lifelong tutor does. A one-time tutor doesn't need mastery paths; a lifelong tutor does. A one-time tutor doesn't need workspaces; a lifelong tutor does.
Lifelong learning doesn't need better models—it needs better infrastructure. Models iterate; infrastructure accumulates. DeepTutor's release every two days is how that infrastructure gets built.
---
Project: https://github.com/HKUDS/DeepTutor Stars today: 1,587 Paper: arXiv:2604.26962 Status: v1.6.15, a release every 2-3 days