[2026.9.14] v1.6.8 — A recycle bin for deleted chats, search across your whole conversation history, a tool that looks past your knowledge base, and a sweep of fixes for quiet failures.

[2026.9.11] v1.6.7 — A fix release: books that arrived as one empty chapter, quizzes that produced nothing, the model's scratchpad in the text, formulas printed raw, and cards you could not submit.

[2026.9.8] v1.6.6 — A fix release: answers that could not submit, a copy button that lied, connected knowledge bases for partners, Codex sign-in inside Docker, and a 100 KB lighter home route.

[2026.9.6] v1.6.5 — A content workspace you point at any folder, one exec tool for every language, Mastery Path modes that gate its tools, and Settings that grades readiness.

[2026.9.3] v1.6.4 — Faster isolated runtimes, controllable Book generation, source-complete Mastery paths and Chat hand-offs, durable Reading, unified activity UI, recoverable sessions, and explicit per-model API capabilities.

[2026.9.2] v1.6.3 — Breaking front/back-end refactor, strict canonical routes and recoverable streams, plus learner/guardian accounts, grounded Reading, WeKnora, broader parsing, Python 3.14, and DashScope media.

[2026.8.31] v1.6.2 — Immersive YouTube learning, a plugin-driven Visualize catalog, three new agent harnesses, safer reading citations, multi-format MinerU, live Partner channel status, and guided updates.

[2026.8.30] v1.6.1 — One vendor key linked to every service it serves, a task model for background work, Settings as a searchable navigator, a sidebar you arrange, and first-party .

Full local Web app + CLI, no clone required. Needs Python 3.11–3.14 and a Node.js 20+ runtime on PATH (the packaged Next.js standalone server is spawned by deeptutor start).

mkdir -p my-deeptutor && cd my-deeptutor
pip install -U deeptutor
deeptutor init     # prompts for ports + LLM provider + optional embedding/search
deeptutor start    # starts backend + frontend; keep the terminal open

deeptutor init prompts for backend port (default 8001), frontend port (default 3782), LLM provider / base URL / API key / model, an optional embedding provider for Knowledge Base / RAG, and an optional search provider for Web Search.

After deeptutor start, open the frontend URL printed in the terminal — by default http://127.0.0.1:3782. Press Ctrl+C in that terminal to stop both backend and frontend. Skipping deeptutor init is fine for a quick trial; the app boots with default ports and empty model settings, configure them later in Settings → Models.

For development against a checkout. Use Python 3.11–3.14 and Node.js 22 LTS to match CI and Docker.

git clone https://github.com/HKUDS/DeepTutor.git
cd DeepTutor

# Create a venv (macOS/Linux). Windows PowerShell:
#   py -3.11 -m venv .venv ; .\.venv\Scripts\Activate.ps1
python3 -m venv .venv && source .venv/bin/activate
python -m pip install --upgrade pip

# Install backend + frontend deps
python -m pip install -e .
( cd web && npm ci --legacy-peer-deps )

deeptutor init
deeptutor start --dev

deeptutor start builds the local web/ frontend for production once and reuses it; --dev runs Next.js with HMR. Config layout, ports, and Ctrl+C match Option 1.

conda create -n deeptutor python=3.11
conda activate deeptutor
python -m pip install --upgrade pip

pip install -e ".[rag-lightrag]"    # Built-in LightRAG engine (exact supported SDK)
pip install -e ".[graphrag]"        # Microsoft GraphRAG engine (Python 3.11–3.13)
pip install -e ".[dev]"             # tests/lint tools
pip install -e ".[partners]"        # Partner IM channel SDKs
pip install -e ".[video-learning]"  # compatibility extra; captions ship in the full/CLI installs
pip install -e ".[matrix]"          # Matrix channel without E2EE/libolm
pip install -e ".[matrix-e2e]"      # Matrix E2EE; requires libolm
pip install -e ".[math-animator]"   # Manim addon; requires LaTeX/ffmpeg/system libs

rm -f web/.next/dev/lock web/.next/lock
deeptutor start --dev

One container for the full Web app. Images on GitHub Container Registry:

• ghcr.io/hkuds/deeptutor:latest — latest stable release
• ghcr.io/hkuds/deeptutor:<version> — exact release without the leading v (for example :1.6.3); pre-releases receive only their version tag

See CONTAINERIZATION.md for podman/rootless/read-only-rootfs deployments and the full per-installation guide.

docker run --rm --name deeptutor \
  -p 127.0.0.1:3782:3782 \
  -v deeptutor-data:/app/data \
  ghcr.io/hkuds/deeptutor:latest

To choose a host content folder at container startup, mount it at the stable container path and lock DeepTutor to that path:

mkdir -p "$PWD/deeptutor-workspace/outputs"
docker run --rm --name deeptutor \
  -p 127.0.0.1:3782:3782 \
  -v deeptutor-data:/app/data \
  -v "$PWD/deeptutor-workspace:/workspace" \
  -e DEEPTUTOR_WORKSPACE_ROOT=/workspace \
  -e DEEPTUTOR_WORKSPACE_ALLOWED_ROOTS=/workspace \
  ghcr.io/hkuds/deeptutor:latest

For Compose, set DEEPTUTOR_WORKSPACE_HOST=/absolute/host/folder before running python scripts/docker_compose.py up -d. When omitted it uses ./data/user/workspace. Docker paths are selected at startup and therefore appear locked in the Web settings page.

Only 3782 needs to be published. The browser talks exclusively to the frontend origin; the Next.js middleware (web/proxy.ts) forwards /api/* and /ws/* to the FastAPI backend inside the container. Publishing 8001 (-p 127.0.0.1:8001:8001) is optional — handy only for hitting the API directly with curl or scripts.

Open http://127.0.0.1:3782. The container creates /app/data/user/settings/*.json on first boot; configure model providers from the Web Settings page. Config, API keys, logs, the default Content Workspace, memory, and knowledge bases persist in the deeptutor-data volume. A separately mounted Content Workspace persists at its host path instead. Optional extras belong on the deployment, not in a shell: set DEEPTUTOR_EXTRAS (and DEEPTUTOR_APT_PACKAGES for system libraries) and every container started from it re-applies them, where a would be lost at the next .

When you don't need the Web UI. The CLI-only package is installed from a source checkout, not from PyPI.

git clone https://github.com/HKUDS/DeepTutor.git
cd DeepTutor

# Create a venv (macOS/Linux). Windows PowerShell:
#   py -3.11 -m venv .venv-cli ; .\.venv-cli\Scripts\Activate.ps1
python3 -m venv .venv-cli && source .venv-cli/bin/activate
python -m pip install --upgrade pip

python -m pip install -e ./packaging/deeptutor-cli
deeptutor init --cli
deeptutor chat

deeptutor init --cli shares the same data/user/settings/ layout as the full app but skips the backend/frontend port prompts. It still offers the Embedding and Search selectors (choose Skip when you do not need them), writes the key runtime files (system.json, auth.json, integrations.json, interface.json, model_catalog.json, main.yaml, agents.yaml), and prompts for the active LLM provider and model.

deeptutor chat                                          # interactive REPL
deeptutor chat --capability deep_solve --tool rag --kb my-kb
deeptutor run chat "Explain Fourier transform"
deeptutor run deep_solve "Solve x^2 = 4" --tool rag --kb my-kb
deeptutor kb create my-kb --doc textbook.pdf
deeptutor memory show
deeptutor config show

The local deeptutor-cli install ships no Web assets or server dependencies. Keep the source checkout around — the editable install points to it. To add the Web app later, install the PyPI package (Option 1) and run deeptutor init + deeptutor start from the same workspace.

The built-in office skills — docx / pdf / pptx / xlsx — work by having the model write a short Python script (python-docx, reportlab, openpyxl, …), run it through the single exec tool, and present the saved workspace file. Those tools mount whenever a sandbox backend is active. DeepTutor selects the strongest configured backend in this order:

• Runner sidecar: DEEPTUTOR_SANDBOX_RUNNER_URL routes execution to the hardened, least-privileged service from Dockerfile.runner.
• Linux bubblewrap: when available, bwrap isolates the process and files.
• Restricted subprocess fallback: local and single-container installs use this only when allowed; under Docker the container remains another boundary.

The sandbox_allow_subprocess setting in data/user/settings/system.json (default true) controls only the last fallback. Set it to false (or export DEEPTUTOR_SANDBOX_ALLOW_SUBPROCESS=0) to refuse subprocess execution when no runner or bwrap backend is available; it does not disable those stronger backends.

Everything under data/user/settings/ is plain JSON/YAML. The Settings page is the recommended editor; workspace registrations live separately in data/user/.runtime/workspaces.sqlite3.

Web Search references are filtered by default: only public http/https URLs without embedded credentials or unusual ports are surfaced. Deployments can add an education-focused domain policy in data/user/settings/system.json:

{
  "web_search_source_filtering": {
    "enabled": true,
    "blocked_domains": ["spam.example"],
    "trusted_domains": ["edu.cn", "arxiv.org"]
  }
}

When trusted_domains is non-empty, references are limited to those domains and their subdomains; blocked_domains always takes precedence.

DeepTutor separates its installed code, private runtime home, and optional Content Workspace. By default, the runtime home is the directory where you run deeptutor init / deeptutor start; --home PATH or DEEPTUTOR_HOME overrides it. Private application state is the data directory inside that home, so the startup banner line beginning with Workspace: identifies that runtime location. If Settings → Workspace points to another folder, back up or remove that content folder separately; it is intentionally not erased by uninstalling DeepTutor.

1. Stop the app. Press Ctrl+C in the terminal running deeptutor start, or run deeptutor stop [--home PATH] for a launcher started with --detach; stop any running Partner and detached Docker containers before deleting data.

2. Remove runtime data only if you also want to erase all local state. This includes settings and API keys, chat history, sessions, Memory, Notebooks, Books, Reading state, Skills, Partners state, logs, Knowledge Bases, parse caches, generated artifacts, and the packaged frontend runtime cache.

   First copy the exact Workspace: path from the startup banner and verify that its data child is the intended DeepTutor data directory. Back it up if anything may be needed later, then move that exact directory to your operating system's Trash/Recycle Bin. Do not run a recursive deletion command against a relative path or an unresolved environment variable.

3. Remove the installed package. Use the command that matches the distribution:

   python -m pip uninstall deeptutor
   python -m pip uninstall deeptutor-cli
   

   If the virtual environment was created only for DeepTutor, remove it through your environment manager. For a source install, deactivate the environment, leave the source directory, and run git status --short inside that exact checkout. Only move the checkout to Trash/Recycle Bin after confirming it contains no unrelated or uncommitted work.

4. For the Docker path, inspect the exact container and named volume before removing them. Volume removal permanently erases the Docker-managed data:

   docker ps -a --filter name=^/deeptutor$
   docker volume inspect deeptutor-data
   docker rm -f deeptutor
   docker volume rm deeptutor-data
   

Chat is the default capability and where most work begins. A single thread can talk normally, call tools, ground itself in selected knowledge bases, read attachments, generate images, consult subagents, write notebook records, and continue with the same context across turns.

The loop is deliberately simple: the model thinks in rounds, calls tools when useful, observes the results, and finishes with a tool-free message. ask_user is special — instead of guessing, the agent can pause the turn, ask a structured clarifying question, and resume once you answer.

User-toggleable tools are brainstorm, web_search, paper_search, zotero_search, reason, and geogebra_analysis — plus imagegen and videogen once you configure the matching generation model. Contextual tools such as rag, kb_files, knowledge_frontier, read_source, read_memory, write_memory, read_skill, load_tools, exec, web_fetch, ask_user, list_notebook, write_note, question_bank, github, consult_subagent, workspace_list, workspace_read, workspace_search, workspace_present, and workspace_export mount automatically when the turn has the right context.

Context comes in two kinds: sticky session context (capability, workspace or course, tools, knowledge bases, persona, model, and Reading / Mastery state) persists across turns; one-time references (files, chat history, books, reading sections, notebooks, question bank, imported agents) come from the + menu for a single turn. The voice button only transcribes the current message.

Home keeps Chat, Ask Questions, Quiz, and Visualize one click away; Research for cited reports, for worked reasoning, and sit under . groups Book, , , Watching, and ; Reading adds verified citations, saved notes, source-grounded read-aloud / study guidance / vocabulary / quiz / translation actions, and notebook capture, while Course Study keeps its course-bound context.

Partners are persistent companions with their own soul, model policy, library, memory, and channels. They are not a separate bot engine: every inbound web or IM message becomes a normal ChatOrchestrator turn inside a partner-scoped workspace. A partner is "a chat that has a personality and a phone number."

Each partner has a SOUL.md, model selection, channels, tool policy, and assigned library. Its library either copies knowledge bases, skills, and notebooks into data/partners/<id>/workspace/, or stays linked to an existing workspace's files and resources; soul, conversations, and Partner memory remain separate. Authenticated non-admin users keep private partner sessions and relationship memory while the partner reads their personal memory read-only; admin, group, and unbound traffic use the shared partner scope.

The channel layer is schema-driven and can connect to IM platforms such as Feishu, Telegram, Slack, Discord, DingTalk, QQ/NapCat, WeCom, WhatsApp, Zulip, Mattermost, Matrix, Mochat, and Microsoft Teams depending on installed extras and configured credentials. A partner can also be connected as a subagent and consulted from a normal chat turn — see My Agents below.

For faster setup, the Partner channel page can create a Feishu/Lark app or WeCom AI bot, or sign a personal WeChat account in, from a QR scan drawn in the browser rather than the server log. Feishu/Lark detects the account domain and saves the scanning user as the initial allowed sender. WeCom keeps an existing allowlist and otherwise defaults to all users who can reach the bot, with a visible open-access warning; the manual channel forms remain available if a provider's scan protocol changes.

My Agents turns other agents into context for DeepTutor, and does two distinct things. Connect a live agent — Claude Code, Codex, Grok CLI, Antigravity, Kimi, opencode, MiMo Code, Hermes Agent, OpenClaw, or DeepSeek Harness on your machine, a remote Hermes gateway, or one of your Partners — and consult it from inside a chat turn: DeepTutor actually runs the other agent and streams its work into the Activity panel via the consult_subagent tool. Select it and its round limit with the Agent chip, or filter the same connected-agent list with @; the choice stays attached to the session.

Connect Grok CLI. Install xAI's Grok CLI on the machine running the DeepTutor backend, run grok login there, and verify that grok --help lists --output-format streaming-json. Then open My Agents → Connect, select Grok CLI, and choose a working directory. Detection checks the executable's protocol support; it does not verify login or model access. The connector has been exercised with Grok CLI 1.0.3; unrelated third-party commands also named grok are not supported.

In Settings → Partners & Agents → Grok CLI, leave model and reasoning effort empty to use the CLI defaults, or enter values supported by your account's grok models output. System instructions are passed through --rules. The default permission mode is dontAsk: Grok uses its existing rules and built-in read-only handling, and denies operations that need approval. This is a CLI permission policy, not a filesystem sandbox. Broader modes can be selected explicitly in settings; advanced CLI flags remain available through backends.grok.extra_args in the subagent settings API.

Grok uses its own authentication and session storage; DeepTutor does not copy its credentials. Follow-up consults resume the connection's session in the same working directory. Text and tool activity stream live; private thought payloads are omitted. Cross-session Grok memory is disabled by default. This connector supports text questions and CLI tools, not image forwarding or importing past Grok conversations. In Docker, install and authenticate Grok inside the backend container; a CLI installed only on the browser's computer is not reachable.

Co-Writer is a split-view Markdown workspace for reports, tutorials, notes, and long-form learning artifacts. Documents autosave and render a live preview (KaTeX math, diagram fences), and can be saved back into notebooks when a draft becomes reusable context. Import a .docx to start a new draft, and export the current editor as Markdown or Word.

Its defining idea is surgical editing: select a span and ask DeepTutor to rewrite, expand, or shorten it. The edit agent can ground the change in a knowledge base or web evidence and keeps a trace of its tool calls. If the draft has not changed while it works, the result replaces the selected text directly and remains reversible with Undo.

Book turns selected sources into an interactive living book — not a static PDF, but a reading environment built from typed blocks. A book can start from knowledge bases, notebooks, question banks, or chat history; the creation flow proposes a chapter outline before content is generated, so you review the shape instead of accepting a blind one-shot output.

Each chapter compiles into editable typed blocks — text, callouts, quizzes, flash cards, timelines, code, figures, interactive HTML, animations, concept graphs, deep dives, and user notes — with its own Page Chat. Insert, move, regenerate, rewrite, or switch a block type; selected passages enter a reviewable learning-capture inbox. Progress, bookmarks, quiz attempts, captures, and Page Chat stay private per reader even when an admin book is shared read-only or for collaborative editing; shared deletion stays admin-only. Any book exports to Markdown, long compiles pause and resume, and deeptutor book health / refresh-fingerprints flag source drift.

Knowledge bases are the document collections behind RAG — they ground Chat turns, Co-Writer edits, Book generation, and Partner conversations. What's distinctive is a choice of retrieval engines: LlamaIndex (the default, hybrid vector + BM25 with optional cross-encoder reranking and exact-flat or HNSW FAISS indexes), PageIndex (reasoning retrieval with page-level citations, hosted or self-hosted OSS), GraphRAG and LightRAG (knowledge-graph retrieval), LightRAG Server (retrieval offloaded to an external LightRAG instance you connect over HTTP), WeKnora (retrieval from a knowledge base in your self-hosted deployment, without a local index or document copy), Tencent IMA (a library you curate in IMA — searched, browsed, and written back to over its OpenAPI), MarginNote 4 (your MN4 study data — documents, excerpts, mind-map cards and the links between them — pushed in by the app's Add-on and navigated with dedicated tools), or a linked Obsidian vault the tutor reads and writes in place. Each KB is bound to one engine.

Migrating an existing Obsidian, Hermes, or Markdown library? See Knowledge migration guide for connected-vault and indexed-copy paths.

Creating a KB, you either create new (upload documents and build a fresh index) or link existing (reuse an index built elsewhere, read in place with no re-index). A KB can also track GitHub repositories (repo, branch, glob) or documentation-site URLs (bounded crawl depth and page count, re-synced every 24 h by default); sync hash-diffs added, changed, and removed content so followed documentation stays current without re-uploading, and linked folders pick up new or changed local files on sync. Re-indexing writes a new flat version-N directory and keeps prior ones, so a working index is never destroyed mid-rebuild. A single document can be removed even from an error-state base — dropping a file that failed to parse without a full delete-and-rebuild. Document parsing — Text-only, MinerU, Docling, Tika, markitdown, PyMuPDF4LLM, or LiteParse — is chosen in , with local model downloads off by default. Docling can also run in mode against a Docling Serve server (no local install or models needed), configured on that page (, a server base URL, and an optional API key) or the / / environment variables. Tika is remote-only and points at the Apache Tika server configured on that page. The CLI mirrors the lifecycle with , source add/remove commands, , and .

Learning Space is the library, organization, and personalization layer. Conversations & Materials holds Chat History, notebooks with movable records and Markdown export, and a question bank with answers and explanations. Practice in Personalized Learning turns saved questions into review sessions, mistake tracking, and scheduled repetition. Personalization holds personas, skills (SKILL.md playbooks), one-click MCP Services, and CLI Apps from the CLI-Anything catalog, each with an on-demand usage guide. The separate My Courses workspace groups subject conversations and tutor threads; each asset is offered only in the workflows that support it.

You don't have to write every skill yourself — Import from EduHub browses the community catalog and downloads a skill straight into your library through a security gate (see Ecosystem).

Memory is a file-backed, three-layer system you can read, curate, and audit — deliberately not a hidden vector store. L1 is the workspace mirror plus an append-only event trace (trace/<surface>/<date>.jsonl); L2 is per-surface curated facts (L2/<surface>.md) with references to L1 entities; L3 is cross-surface synthesis (L3/<profile|recent|scope|preferences>.md) that records its contributing L2 surfaces.

The Memory Graph shows the whole pyramid — L3 synthesis at the centre, L2 in the middle ring, L1 traces on the outside — with exact L2 → L1 evidence edges and L3 → contributing-surface links. Memory is tracked across chat, notebook, quiz, kb, book, partner, and cowriter surfaces; the consolidator's Update / Audit / Dedup budgets are tuned in Settings → Memory.

Settings is the operational control plane, opening on General for interface and model output language. Its searchable navigator links to independent pages: Personal covers Workspaces, Data migration, Appearance, and Usage statistics; Learning & conversation covers starting points, attachments, Video Learning, learner and guardian controls, Learning progress, and Memory; Models & services covers Providers, Language models, Task models, Embedding, Search, Voice, and Multimodal generation; Features & integrations covers tools, capability parameters, Partners & agents, and Knowledge & documents. System holds Network, Runtime status, and About; Archived chats lets you search, restore, or permanently delete archived conversations. Runtime status contains backend health, resident memory, and the Readiness matrix grading capability blockers, warnings, and suggestions. Workspaces keeps topic files and learning state separate, with verified migration and export under Data migration. A provider holds a vendor's address and credential for reuse by its service models; the model pages choose saved providers and configure model names and capabilities. Task models pin a small, fast model for background work — naming conversations and writing starting points — and resolve to the active default when empty. Voice groups speech synthesis and transcription; Multimodal generation groups image and video models. Partners & agents configures local harnesses and a remote Hermes gateway.

Video Learning under Settings → Learning & conversation defaults to the official privacy-enhanced YouTube IFrame Player. To keep playback local, set the administrator-managed Invidious API origin (for example http://127.0.0.1:3000), test it, select Invidious, and save. New or reopened videos pick up the provider immediately with the same material ID and progress. Invidious media is streamed through DeepTutor's byte-range proxy; upstream URLs are neither exposed to the browser nor stored on disk. If the instance fails, DeepTutor stays offline from YouTube until the learner explicitly chooses the native YouTube fallback. Public-caption tutoring is optional: install .[video-learning]; playback continues without it, while transcript-based Explain here is disabled with a reason.

Authentication is off by default — DeepTutor runs single-user. Turn it on and one data/ tree hosts an admin workspace, isolated per-user workspaces, and partner workspaces side by side:

data/
├── user/                    # Admin workspace + global settings
├── users/<uid>/             # Per-user scope: chat history, memory, notebooks, KBs
├── partners/<id>/workspace/ # Partner (synthetic-user) scope
├── cli-apps/                # Installed CLI apps, mounted read-only into the sandbox
└── system/                  # auth · grants · audit · user-secrets/<owner> (OAuth tokens)

The first registered user becomes admin and owns model catalogs, provider credentials, shared knowledge bases, skills, canonical shared books, and per-user grants. Admin-created local users choose Standard, Learner, or Custom. Learner locks learning capabilities and material policy, adds an adaptive profile, and supports revocable device credentials with expiry and daily limits; authorized guardians can view reports, approve materials, and reset credentials. Other users get isolated workspaces plus scoped models, KBs, skills, partners, and shared-book access without receiving raw API keys. If auth.json already carries a username + password_hash, that account is the admin: /register stays closed and accounts created from /admin/users are always role=user until you promote them.

Enable it: turn auth on in data/user/settings/auth.json, restart deeptutor start, register the first admin at /register, then add users from /admin/users and assign models, KBs, skills, partners, tool/MCP/CLI-app policy, and code-execution access through grants; configure shared books under each user's Book access panel.

For split private/public origins, set auth.private_login_hosts (or AUTH_PRIVATE_LOGIN_HOSTS) to the private frontend hosts that may show password sign-in and registration. The frontend forwards the incoming HTTP Host to the backend as its frontend-host assertion. Preserve the browser's Host through your reverse proxy, and make the public ingress reject requests naming a private host; do not expose a raw Next.js port that accepts arbitrary Host values. HTTP Host can be forged by a direct client, so private-host authorization depends on that ingress boundary. The backend accepts frontend-host assertions only from loopback by default. If the Web frontend connects from another container or host, set to that frontend proxy's exact IP address on the backend process (comma-separated for more than one). Keep the backend API private to the frontend proxy and do not include general client networks in this list. Loopback is always allowed; when the list is non-empty, an authenticated user on a private origin can open and create a short-lived, host-bound pairing link for an HTTPS public origin. The public page exchanges the one-time code for an equally short JWE ticket in a POST body, consumes the ticket once, and receives the normal HttpOnly session cookie.

deeptutor chat opens an interactive REPL and selects a mode with --capability; deeptutor run <capability> "<message>" takes that capability as its first positional argument and exits after one turn. Both accept --tool, --kb, --config, and --workspace to select a registered workspace.

deeptutor chat                                              # interactive REPL
deeptutor chat --capability deep_solve --kb my-kb --tool rag
deeptutor run chat "Explain the Fourier transform" --tool rag --kb textbook
deeptutor run chat "Find recent work beyond this material" --kb textbook --tool knowledge_frontier
deeptutor run deep_research "Survey 2026 papers on RAG" \
  --config mode=report --config depth=standard

Core workspace management is here too — knowledge bases (kb), sessions (session), partners (partner), skills (skill), notebooks, memory, and config; course and session organization remain in the Web app. Full list below.

DeepTutor is built to be operated by another agent. Add --format json to any run and each turn streams NDJSON — one event per line (content, tool_call, tool_result, done, …), every line tagged with its session_id. Runs are headless-safe: an ask_user pause with no TTY auto-resolves with an empty reply instead of hanging.

# One shot, machine-readable
deeptutor run deep_solve "Find d/dx[sin(x^2)]" --tool reason --format json

# Chain turns in one stateful session — capture the id, reuse it
SID=$(deeptutor run deep_research "Survey 2026 papers on RAG" \
  --config mode=report --config depth=standard --format json \
  | jq -r 'select(.type=="done").session_id')
deeptutor run deep_question "Quiz me on that survey" --session "$SID" --format json

The repo ships a root SKILL.md — a ~200-line handover doc that teaches any tool-using LLM the whole surface in one read. Hand it to Claude Code, Codex, or OpenCode (they pick up SKILL.md automatically), or wrap deeptutor run as a tool in a LangChain / AutoGen loop. Full recipes: Agent Handoff.

The CLI-only package lives in packaging/deeptutor-cli. In this checkout, install it from source:

python -m pip install -e ./packaging/deeptutor-cli

It isn't published to PyPI yet, so the main Get Started section keeps the source-install path.

EduHub is the community hub DeepTutor launched for sharing teaching-oriented agent skills — Socratic tutors, flashcard builders, essay feedback, exam blueprints, concept explainers, and more. It is built into DeepTutor, so there's nothing to configure: a bare slug or an eduhub: prefix resolves to it.

Find and install — in the browser, open Learning Space → Skills → Import from EduHub to browse the catalog and download a skill straight into your library. From the terminal:

deeptutor skill search "socratic tutor"               # search EduHub (the default hub)
deeptutor skill install socratic-tutor                # fetch → verify → register
deeptutor skill install eduhub:socratic-tutor@1.2.0   # pin a hub and a version
deeptutor skill list                                  # local skills with their hub provenance

Publish your own — package a SKILL.md and share it back to the community:

deeptutor skill login                                 # browser sign-in to EduHub
deeptutor skill publish ./my-skill                    # interactive: pick a track + tags, then upload
deeptutor skill update                                # roll back or release a new version

EduHub is also a standalone, ClawHub-compatible registry, so agents that aren't DeepTutor (Claude Code, Codex, …) can use it directly through the eduhub CLI — npx eduhub install socratic-tutor.

Whatever the source, every import passes the same safety gate before anything touches your workspace:

• the registry's security verdict is checked first — flagged packages are refused unless you pass --allow-unverified;
• archives are extracted defensively with path-traversal, entry-count, size, compression-ratio, suffix, and symlink checks; executable bits are stripped, while extensionless files remain allowed;
• frontmatter is normalized to DeepTutor's schema and always: is stripped, so a downloaded skill can never force itself into every system prompt;
• provenance — hub, version, verdict, and install time — is written to .hub-lock.json for audits and updates.

In multi-user deployments, browser imports land in the authenticated caller's skill layer, while CLI and admin-console installs target the owner/admin workspace; admin skills stay hidden and read-only for ordinary users until granted.

Because DeepTutor speaks the open Agent-Skills format, ClawHub works as a first-class source too — it's built in alongside EduHub. Pick it with the hub prefix:

deeptutor skill search "git release notes" --hub clawhub
deeptutor skill install clawhub:git-release-notes@1.0.1
deeptutor skill install clawhub:udiedrichsen/stock-analysis

When several publishers share the same slug, search shows each publisher and a fully scoped install ref (clawhub:<ownerHandle>/<slug>).

Add more registries in data/user/settings/skill_hubs.json: a type: "clawhub" entry points at any compatible HTTP API (EduHub and ClawHub both speak it), type: "command" wraps whatever fetch CLI a registry ships, and "default" chooses the hub used for bare slugs. All of them feed the same import gate.