The full learning loop

Most AI tools stop at "here's some text". This one closes the loop:

• Lessons that look like lessons — articles with real sourced images, Mermaid diagrams, galleries and sandboxed interactive widgets. Every draft goes through an editor/fact-check pass before you see it.
• Comprehension tests — question pools that check understanding, not verbatim recall, and interleave concepts from earlier modules.
• Real homework — essays, diagrams, file uploads, GitHub repos, and autograded coding tasks that actually run your code. The agent reviews submissions and makes you retry until it passes.
• Spaced repetition — flashcards are extracted from each lesson and scheduled for review, so the course keeps working on you after you've read it.
• Lecture audio — free OS voices out of the box, optional premium Gemini TTS, cached on disk.

Don't want the full treatment? Checkboxes at creation turn tests and homework off, and you can skip the clarifying interview entirely — title, plan, go.

Roadmaps: see the whole journey

For big goals ("become a data engineer", "learn academic painting from zero") a single course is the wrong shape. A roadmap lays out stages and skills, runs a quick diagnostic to find out what you already know, and spawns a lesson or a full course from any skill — each one aware of where it sits in the bigger picture.

Your materials, your sources

Drop documents, links and folders into a Space and courses created there ground themselves in your material — strictly (only your sources) or openly (your sources first, the web second). Attach custom MCP servers to a course and the agent can research through any tool you trust.

Private catalogs for teams

This is the part companies asked for. Spin up your own catalog server inside your infrastructure — one Docker command, hidden from the public internet:

docker run -d -p 8080:8080 \
  -e PUBLIC_ORIGIN=http://catalog.internal.example.com:8080 \
  -e CATALOG_UPLOAD_TOKEN=your-secret \
  -v laa-catalog-data:/data \
  legostin/laa-catalog:latest

Everyone on the team adds the URL in Settings and gets a shared internal course library: onboarding tracks, domain knowledge, tooling guides. Authors publish with the team token; everyone else browses, installs and pulls updates with no token at all. Courses remember which catalog they came from, so update checks keep working even across reconfigurations. The public catalog stays available alongside.

And of course: publish your best courses to the public catalog, install other people's courses, translate any course into another language — structure, lessons, tests, homework, diagram labels and even baked-in image text included.

Generate courses from Claude Code (MCP)

Author and publish courses straight from Claude Code: a built-in MCP server (laa-course) lets the model design the structure, write and fact-check the lessons, pick images and cite sources itself, then save and publish them to your catalog — including arbitrarily-nested documentation with working cross-links and space-grounded courses (build only from supplied docs/repos). Generation runs inside Claude Code; the server only persists, lists status, edits structure and publishes (it never calls an LLM).

The server ships inside the app and is a single, zero-dependency file — you only need Claude Code and node on your PATH. The easiest way: open Settings → Generate courses from Claude Code and click Copy command — it's prefilled with the correct path for your OS. Or register it by hand:

# macOS (path inside the installed .app)
claude mcp add laa-course \
  --env CATALOG_URL=http://localhost:8080 --env CATALOG_UPLOAD_TOKEN=your-token \
  -- node "/Applications/Learn (Almost) Anything.app/Contents/Resources/sidecar/src/course-mcp/server.mjs"

# Windows (path inside the install dir; adjust if you installed elsewhere)
claude mcp add laa-course ^
  --env CATALOG_URL=http://localhost:8080 --env CATALOG_UPLOAD_TOKEN=your-token ^
  -- node "C:\Program Files\Learn (Almost) Anything\resources\sidecar\src\course-mcp\server.mjs"

# Linux (AppImage/deb — adjust to your install path)
claude mcp add laa-course \
  --env CATALOG_URL=http://localhost:8080 --env CATALOG_UPLOAD_TOKEN=your-token \
  -- node "/usr/lib/learn-almost-anything/resources/sidecar/src/course-mcp/server.mjs"

Verify with claude mcp list (→ laa-course: connected), then just ask: "generate documentation on how HTTP/2 works and publish it". Courses are stored under $LAA_COURSE_STORE (default ~/.laa-course-mcp). The repo also ships a .claude/skills/generate-course skill that drives the whole authoring workflow.

Your subscription is the engine

The app is free and runs no paid backend. Every LLM call goes through an agent CLI already installed and authenticated on your machine:

Install both and pick per course. Optional extras, each off by default: Brave Search API (web/image grounding), Gemini API (generated illustrations, premium TTS). A quality/cost tier per course (quick / balanced / premium) controls research depth, reasoning effort and how much material gets generated — so a quick mini-course stays cheap and a premium deep-dive goes all in.

Provider pricing changes; check Claude Code plans, Codex pricing, Gemini API, Brave Search API.

Get started

1. Download the latest build from Releases — macOS .dmg (Apple Silicon / Intel, signed and notarized) or Windows .msi/.exe (unsigned for now, SmartScreen may warn).
2. Make sure Node.js 20+ is installed — the local sidecar runs the agent SDKs through it.
3. Have at least one agent CLI logged in (table above), then launch the app and create your first course.

The UI ships in English and Russian; course content can be generated in any language you pick — a single library happily mixes English, Russian and Chinese courses.

Installed builds self-update: the app checks GitHub Releases, downloads a signed updater bundle, verifies and installs it.

How it works under the hood

You pick one agent (Claude or Codex) when creating the course; every LLM step then runs through it via a local Node sidecar:

1. Interview — a few adaptive clarifying questions become the course brief (skippable).
2. Plan — the agent researches (web / Context7 / MediaWiki / arXiv / OpenAlex / your Space), designs the module tree and classifies the subject category.
3. Per-lesson generation — draft (article + widgets) → editor & fact-check review → widget validation; then illustrations (real image vs code snippet, per block), a test, homework and flashcards in parallel. Accuracy-critical categories get an extra background fact-check pass.

flowchart TD
  U["Topic, language, format, agent, space"] --> CC["create_course"]
  CC --> SC[["Node sidecar (Claude Code / Codex)"]]
  SC --> WQ["Interview → course brief"]
  WQ --> BS["Plan: research → curriculum → category"]
  BS --> LOOP{"For each lesson"}
  LOOP --> D1["Draft: article + widgets"]
  D1 --> D2["Editor + fact-check review"]
  D2 --> D3["Widget validation"]
  D3 --> ILL["Illustrations"]
  D3 --> TST["Test"]
  D3 --> HW["Homework"]
  D3 --> FC["Flashcards"]
  ILL --> RDY["Lesson ready"]
  TST --> RDY
  HW --> RDY
  FC --> RDY
  RDY --> LOOP
  LOOP -->|all done| FIN(["Course ready"])

Stack: Tauri 2 (desktop shell) · React 19 + TypeScript + Vite · Node sidecar calling @anthropic-ai/claude-agent-sdk and @openai/codex-sdk · SQLite + files for local storage · Playwright + system Chrome for visual widget checks · bundled MCP servers for controlled research tools.

Local data and privacy

• Courses, progress and media live in the local app data directory. No Learn server hosts your content.
• Agent providers receive only the prompts and course context needed for generation; optional Gemini/Brave integrations receive only the requests for features you enabled.
• Catalog publishing and ngrok sharing happen only when you explicitly trigger them.

Latest releases

• v0.3.0 — private self-hosted catalogs (Docker image + multi-server support in the app), tests/homework toggles and a skippable interview at course creation, multiline topic i