DeepTutor is an open-source, agent-native personalized tutoring and learning workspace built by HKUDS, and it has collected a lot of attention fast: the GitHub API reports 34,646 stars and 4,416 forks on HKUDS/DeepTutor, a Python project under Apache-2.0 created on 2025-12-28. Stars measure interest, not quality, so treat that number as a signal that people are looking, nothing more. The interesting claim is architectural. Chat, quiz generation, research, problem solving, visualization and mastery practice all run on one agent loop, so the learner context follows you when the objective changes.
Why an agent-native AI tutor matters right now
Most LLM study helpers are session-bounded. You ask, they answer, and the next conversation starts from nothing. The DeepTutor paper puts the problem bluntly: deployed LLM tutors adapt to the immediate prompt rather than to a persistent learner model, and their functions are often implemented as isolated modules that share little state with one another. That is why the quiz you generate on Tuesday knows nothing about the misconception you exposed on Monday.
DeepTutor was released on 2025-12-29 according to the README news log, and the same log records 10k stars in 39 days and 20k in 111 days. Those are attention figures, and they cut both ways: a repository can trend hard and still be young. What makes the project worth reading anyway is the design decision underneath. Instead of bolting features onto a chatbot, the team built a personalization substrate first and made every feature share it.
Who actually gains from a personalized learning platform like this
Honest answer: not the person who wants one quick explanation. A single question is better served by any hosted assistant. The payoff arrives when you have your own materials (a textbook PDF, lecture notes, a question bank) and you keep coming back for weeks. Because the memory and the knowledge bases persist across surfaces, the value compounds instead of resetting.
How DeepTutor works under the hood
Two plugin layers, three entry points: CLI, WebSocket API and Python SDK
The architecture overview describes a two-layer plugin model: single-shot Tools that the LLM picks on demand, and multi-stage Capabilities that take over a whole turn. Both are exposed through three entry points, a CLI, a WebSocket API and a Python SDK, per the project’s AGENTS.md. Four tools are user-toggleable (breadth-first idea exploration with rationale, web search with citations, arXiv preprint search, and a dedicated deep-reasoning call). The rest are context-gated: the chat capability mounts them automatically depending on whether a knowledge base exists, whether attachments are present, whether a sandbox is available.
Capabilities are pipelines with named stages. One runs planning → reasoning → writing. Another runs rephrasing → decomposing → researching → reporting. A third goes concept_analysis → concept_design → code_generation → code_retry → summary → render_output. Every capability converges on the same finish path, so each turn emits one envelope on a shared StreamEvent protocol with async fan-out to consumers. In practice that is why the CLI, the browser and the SDK see identical tool traces.
The hybrid personalization engine and multi-resolution memory
The paper describes a hybrid personalization engine that couples static knowledge grounding with dynamic multi-resolution memory, distilling interaction history into a continuously evolving learner profile. In the running app this shows up as three layers: L1 traces, L2 surface summaries, L3 synthesis. The README calls it inspectable memory, and the detail I like is the Memory Graph, which traces every claim back to its evidence. So the learner profile is editable rather than a black box you have to trust.
Multi-engine retrieval and knowledge graph RAG
Retrieval is not a single pipeline. DeepTutor keeps versioned RAG libraries across LlamaIndex, PageIndex, GraphRAG and LightRAG, or points at a linked Obsidian vault, with pluggable document parsing. Release notes fill in the mechanics: v1.4.12 added a LightRAG Server retrieval engine, a lightweight PyMuPDF4LLM parsing engine and a FAISS vector backend for large knowledge bases; v1.5.2 added PageIndex retrieval that reasons across documents via agentic tool calls; v1.5.9 brought Gemini Embedding 2 on its native endpoint. The upstream credit matters here, since LlamaIndex, LightRAG, FAISS, MinerU and Obsidian are doing real work inside this system.
The closed loop between solving and question generation
Here is the part that separates DeepTutor from a RAG chatbot with a quiz button. The paper describes a closed tutoring loop that bidirectionally couples citation-grounded problem solving with difficulty-calibrated question generation. Solving cites your sources; the generator uses your diagnosed weaknesses to pick what to ask next. Because both sit on the same personalization substrate, collaborative writing, multi-agent deep research and interactive guided learning inherit the same learner state.
The concrete surfaces follow from that. Guided Learning was rebuilt on the chat agent loop in v1.4.5 with a per-type mastery gate and a /learning dashboard, and v1.4.9 wired graded Mastery Path questions into the Question Bank. Meanwhile Partners turned the old TutorBot idea into persistent IM companions on a production-grade pipeline covering 15 channels with live streaming (v1.4.3), each with its own private memory (v1.4.8). Subagents go the other direction: from any turn you can consult a live coding CLI, Claude Code, Codex, Gemini, Kimi, opencode or MiMo, or import its past conversations.
Eight surfaces, one running context
The documentation site the README links as its Docs destination frames it as eight surfaces sharing one runtime: Home, Partners, My Agents, Co-Writer, Book, Learning Space, Memory and Knowledge Center. The repository layout matches that shape, with route groups for admin, auth, utility and workspace pages under web/app/. Under the Python package, deeptutor/services/ alone contains 26 directories, from llm/ and rag/ to voice/, videogen/ and sandbox/.
Installing DeepTutor locally: four paths, one workspace
All four installation paths share the same layout: settings live in data/user/settings/ under the directory you launch from, or under DEEPTUTOR_HOME / deeptutor start --home if you set one. The recommended flow for the full app is pick a workspace directory, install, then deeptutor init and deeptutor start.
PyPI: the full local web app plus CLI
This path needs Python 3.11 to 3.13 and a Node.js 20+ runtime on PATH, because deeptutor start spawns the packaged Next.js standalone server.
mkdir -p my-deeptutor && cd my-deeptutor
pip install -U deeptutor
deeptutor init # prompts for ports + LLM provider + optional embedding
deeptutor start # starts backend + frontend; keep the terminal opendeeptutor init asks for the backend port (default 8001), the frontend port (default 3782), your LLM provider, base URL, API key and model, plus an optional embedding provider for the knowledge base. Then open the frontend URL it prints, by default http://127.0.0.1:3782, and stop both processes with Ctrl+C. Skipping init is fine for a trial, since you can configure models later in Settings.
Docker: one container, one published port
Images live on GitHub Container Registry as ghcr.io/hkuds/deeptutor:latest for stable and ghcr.io/hkuds/deeptutor:pre for pre-releases.
docker run --rm --name deeptutor \
-p 127.0.0.1:3782:3782 \
-v deeptutor-data:/app/data \
ghcr.io/hkuds/deeptutor:latestOnly 3782 needs publishing, because the Next.js middleware (web/proxy.ts) forwards /api/* and /ws/* to the FastAPI backend inside the container. Publishing 8001 is optional and useful mainly for curl. One trap worth remembering: inside Docker, localhost is the container, so a model server on your machine is reached through host.docker.internal, for example http://host.docker.internal:11434/v1 for Ollama or http://host.docker.internal:1234/v1 for LM Studio, with --add-host=host.docker.internal:host-gateway on Linux.
Source and CLI-only installs
For development you clone the repo, create a venv, run python -m pip install -e ., install frontend deps with npm ci --legacy-peer-deps, then deeptutor start --dev for Next.js with HMR. Extras are opt-in: pip install -e ".[dev]", ".[partners]", ".[matrix]", ".[matrix-e2e]" (needs libolm) and ".[math-animator]" for the Manim addon, which wants LaTeX and ffmpeg on the system. If you want no web UI at all, the CLI-only package installs from a source checkout with python -m pip install -e ./packaging/deeptutor-cli, then deeptutor init --cli and deeptutor chat. That variant defaults embeddings to off and ships no web assets.
Workflows that show what the runtime is for
The CLI is the fastest way to feel the tool and capability split. A knowledge base becomes a flag, not a separate app:
deeptutor chat --capability deep_solve --tool rag --kb my-kb
deeptutor run deep_solve "Solve x^2 = 4" --tool rag --kb my-kb
deeptutor kb create my-kb --doc textbook.pdf
deeptutor memory showThe office skills are a good second test. For docx, pdf, pptx and xlsx, the model writes a short Python script using libraries like python-docx, reportlab or openpyxl, runs it through the exec / code_execution tools, and hands back a download URL. Sandboxing is on by default everywhere: a restricted subprocess locally and in the single container, while docker-compose routes execution to a least-privileged runner sidecar (Dockerfile.runner) via DEEPTUTOR_SANDBOX_RUNNER_URL, which the project treats as the strongest posture.
Skills, EduHub and the community registry
Skills are installable rather than hard-coded. v1.4.4 added deeptutor skill install behind a security gate for community skills from ClawHub, and the README’s ecosystem section documents publishing your own with deeptutor skill login, deeptutor skill publish ./my-skill and deeptutor skill update, with EduHub described as a standalone, ClawHub-compatible registry that non-DeepTutor agents can use through the eduhub CLI. Five built-in skill directories ship in the tree (docx, pdf, pptx, xlsx and skill-creator), and v1.5.7 added a per-account MCP Services store plus 101 CLI Apps the tutor can run.
The other DeepTutor, and why the confusion is fair
Search the name and you will hit a second project. The University of Memphis ran an intelligent tutoring system also called DeepTutor, funded by the Institute of Education Sciences and led by Vasile Rus, built on Learning Progressions and a semantic logic form representation for dialogue. It is unrelated to HKUDS/DeepTutor, and it predates LLM tutors entirely.
The comparison is still instructive. That older system encoded pedagogy explicitly, as sequences of mental models students pass through on the way to mastery. The HKUDS system learns the learner instead, from interaction history distilled into a profile. Different bets, same target. If you are evaluating adaptive pedagogy claims, knowing both exist keeps you from citing the wrong paper.
Limits, caveats and where it is going
Release cadence is fast, which is a mixed blessing. The current version is v1.5.11, published 2026-08-09 (its own notes date the release 2026.08.10), and it fixes things that were visibly broken days earlier: prose around a tool call vanishing from replies, a truncated generation being read as a finished one, LightRAG indexing sitting on the event loop, plus live memory usage in Settings. Useful fixes, and also a reminder that a project shipping this often is still settling.
Two more things to weigh. The GitHub API reports 99 open issues and pull requests combined, which describes volume of activity and nothing about responsiveness. And you supply the intelligence: every path prompts for an LLM provider and key, so cost and model quality are yours to manage. On the plus side, the README states that DeepTutor is an open-source project led by Bingxi Zhao within the HKUDS Group, iterating in fully open-source form, with no paid online products of any kind so far.
On evaluation, keep the paper’s framing intact. The authors built TutorBench, a student-centric benchmark with source-grounded learner profiles and a first-person interactive protocol, evaluated agentic reasoning across five benchmarks, and report that DeepTutor improves personalized tutoring quality while maintaining general agentic reasoning. No public numbers appear in the material I have, so I am not going to invent any. The credited team is Bingxi Zhao, Jiahao Zhang, Xubin Ren, Zirui Guo, Tianzhe Chu, Yi Ma and Chao Huang, from the University of Hong Kong and Beijing Jiaotong University. One naming detail worth flagging: the documentation site footer credits the Data Intelligence Lab at HKU, while some coverage of the project calls HKUDS the Data Science Lab at the University of Hong Kong.
People Also Ask
What is DeepTutor?
DeepTutor is an open-source, agent-native learning workspace that connects tutoring, problem solving, quiz generation, research, visualization and mastery practice in one extensible system. Chat, Quiz, Research, Visualize, Solve and Mastery Path run on the same agent loop, so switching objective does not mean switching tools. Knowledge bases, books, Co-Writer drafts, notebooks, question banks, personas and Memory stay available across every workflow.
Is DeepTutor open source?
Yes. The repository is licensed under Apache-2.0, and the README states the project iterates in fully open-source form, built with the community. It also says there are no paid online products of any form so far. You still pay whichever LLM provider you configure, since DeepTutor runs on your keys and your machine.
Who developed DeepTutor?
DeepTutor comes from HKUDS at the University of Hong Kong, and the README describes it as led by Bingxi Zhao within the group. The accompanying arXiv paper, “DeepTutor: Towards Agentic Personalized Tutoring”, lists Bingxi Zhao, Jiahao Zhang, Xubin Ren, Zirui Guo, Tianzhe Chu, Yi Ma and Chao Huang, affiliated with the University of Hong Kong and Beijing Jiaotong University. Note that an unrelated intelligent tutoring system of the same name was developed at the University of Memphis.
How do I install DeepTutor locally?
The smoothest route is PyPI: create a workspace directory, run pip install -U deeptutor, then deeptutor init and deeptutor start, and open http://127.0.0.1:3782. You need Python 3.11 to 3.13 and Node.js 20+ on PATH. Alternatively, run one container with ghcr.io/hkuds/deeptutor:latest publishing port 3782, install from source for development, or install the CLI-only package from ./packaging/deeptutor-cli if you want no web UI.
What features does DeepTutor include?
One runtime for chat, quiz, research, visualization, solving and mastery practice; versioned multi-engine retrieval across LlamaIndex, PageIndex, GraphRAG, LightRAG or a linked Obsidian vault; three-layer inspectable memory with a Memory Graph that traces claims to evidence; Partners as persistent IM companions; subagents that consult a local coding CLI mid-turn; and extensible tools, MCP servers, CLI apps and installable community skills. The Book engine compiles knowledge bases and notebooks into interactive books, and Co-Writer is a Markdown workspace with knowledge-base or web grounding.
Worth cloning if you learn from your own materials
If your study material is already digital and you keep returning to the same subject, DeepTutor is the rare project where persistent memory is the feature rather than a marketing line. Start with the PyPI path, index one textbook, run deeptutor chat --capability deep_solve --tool rag --kb my-kb, then open Memory and read what it decided about you. That single step tells you more than any benchmark table, because the personalization is inspectable by design.