plato：开源 AI 微学习平台，11 轮对话约 20 分钟完成一课

An Open Source, AI-powered microlearning platform. Learners work through focused, exemplar-driven lessons in a continuous conversation with an AI coach that creates activities, evaluates submissions, and tracks progress toward mastery — all in under 20 minutes.

Built by 11:11 Philosopher's Group.

Special thanks to UIC Tech Solutions, UIC TS Open Source Fund, WordPress, Louisiana Tech, and the ULL Louisiana Educate Program.

Looking to extend plato? plato supports plugins like WordPress: add custom user fields, new admin KPIs, AI agents, lifecycle hooks, and more. Run node scripts/create-plato-plugin.js my-plugin to scaffold one in seconds, or read the plugin authoring guide (and the AI-agent guide if you're working with Claude Code or similar tools).

How it works

plato applies microlearning principles through AI-powered personalization. Each lesson is a focused experience designed to be completable in ~11 exchanges (~20 minutes), built around a single exemplar and 2-4 learning objectives.

A lesson defines an exemplar (the mastery-level outcome a learner produces) and a set of learning objectives. When a learner starts a lesson, an AI coach opens a conversation and guides them through activities — coaching, creating tasks, evaluating submissions (text or images), and tracking progress — all in a single continuous chat. The coach enriches a knowledge base as the learner progresses, adapting to their strengths and weaknesses until they achieve the exemplar.

Microlearning pacing

Lessons are designed for completion within 11 exchanges (~20 minutes), but the system never cuts a learner off. The coach adapts its approach as exchanges accumulate — and always decides when the exemplar has been demonstrated. There is no hard cutoff and no forced closure.

The admin dashboard tracks an On-Target Rate KPI showing what percentage of lessons complete within the 11-exchange target. A low rate means the lesson design or coach prompt probably needs tuning — not that pacing should be enforced more aggressively. Extended lessons (2× target or beyond) are surfaced as informational diagnostics, never as metrics to drive to zero.

The dashboard also tracks two Learner Engagement KPIs: percentage of learners who have started any lesson (target >90%) and percentage who have completed more than half of their available lessons (target >50%). Both come from GET /v1/admin/stats/lessons, which is stale-while-revalidate cached (~10 min freshness) so dashboard loads stay fast. A Refresh button on the dashboard bypasses the cache and recomputes synchronously.

Admins manage everything from /plato: lessons, users, a classroom customizer (styles + knowledge base), and plugins.

Reporting issues

Issues and feature requests go in GitHub Issues. An automated intake agent reads every new issue and either:

• Tags it ready-for-pilot — enough detail is present, a maintainer or the pilot agent will pick it up
• Tags it needs-info and posts a few focused clarifying questions — reply inline when you can
• Closes it politely (with an invitation to reopen) if it's spam, off-topic, or abusive

To skip the needs-info round-trip, include upfront:

• The URL or page where it happened
• What you did (exact steps)
• What you expected vs. what actually happened
• Any error message, screenshot, or browser console output
• Your browser + OS, and whether you were signed in as a learner or admin

The intake agent only asks for things you can provide. It never asks you to inspect code — that's our job.

Quick start

Prerequisites

• Node.js 20+
• npm

Setup and run

# Clone the repo
git clone https://github.com/1111philo/plato.git
cd plato

# Install dependencies (client and server)
cd client && npm install && cd ../server && npm install && cd ..

# Build the client (server serves the built files)
cd client && npm run build && cd ..

# Configure your environment
cd server && cp .env.example .env
# Edit .env, then make AWS credentials with Bedrock access available (see "AI provider")

# Start the dev server (uses SQLite for data — no Docker needed)
node dev-sqlite.js

Open http://localhost:3000.

On first visit you'll name your classroom and create an admin account. Prompts and lessons are seeded automatically. The knowledge base is created by admins through the conversational KB Editor in the Customizer.

AI provider

plato runs a single open source model on Amazon Bedrock — Qwen3-VL 235B A22B, under the OSI-approved Apache-2.0 license. All nine agents share it; there is no per-agent routing.

The license is a requirement, not a preference: plato is AGPL-3.0, so the model has to be open source, not merely open weight. That rules out models under bespoke community licenses (Llama 4, Gemma) even where they benchmark well.

Bedrock is the only backend, in production and in local dev. Provide AWS credentials with bedrock:InvokeModel / bedrock:InvokeModelWithResponseStream permission and enable model access for qwen.qwen3-vl-235b-a22b in the Bedrock console. Any standard credential source works locally — AWS_PROFILE, aws sso login, or AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY in server/.env. Set AWS_REGION if the model isn't enabled in us-east-2.

Without credentials the app is fully navigable, but lesson conversations won't start.

To run a different model, change the single LLM constant in server/src/lib/ai-provider.js (and the matching one in client/js/api.js). Anthropic model IDs are still wired up, so falling back to Claude is a one-line change — though anything other than an OSI-licensed model gives up the open source property above. See docs/MODEL_SELECTION.md for why this model — the four constraints, the benchmarks, and what a replacement has to satisfy.

Then log in and navigate to /plato to see the admin dashboard, or /lessons to start learning.

Project layout

plato/
  client/                React 19 + Vite SPA (learner and admin UI)
  server/                Node.js + Hono + AWS Lambda + DynamoDB (API, auth, data, AI proxy)
  plugins/               Built-in and community plugins (e.g. plugins/slack)
  packages/plugin-sdk/   TypeScript types for plugin authors
  docs/plugins/          Plugin authoring docs (start at AUTHORING.md or AGENTS.md)
  scripts/               Build, deploy, and plugin scaffolding tooling
  docs/                  Extended guides (deployment, etc.)

For architectural details (AI agents, data model, auth, conventions) see CLAUDE.md.

Extending plato

There are two contribution paths and they have different review bars:

Build a plugin (most common). Plugins live in plugins/<id>/ and have a lighter review bar — they sit alongside core, declare what they touch via capabilities, and can't override completion semantics or other core invariants. Scaffold a working plugin with:

node scripts/create-plato-plugin.js my-plugin --name "My Plugin"

Then read docs/plugins/AUTHORING.md (humans) or docs/plugins/AGENTS.md (AI agents). The full extension reference is at docs/plugins/EXTENSION_REFERENCE.md. Plugins can add admin pages, custom settings UI, server routes, lifecycle hooks, and more.

Contribute to plato core. Anything outside plugins/ is core — coach, lessons, KPIs, agents, the plugin host itself. See CONTRIBUTING.md for setup and review process; CLAUDE.md for architecture context. Core changes require more review than plugin changes because they affect every plato deployment, including the public plugin contract.

Deployment

For production deployment to AWS — SAM setup, CI/CD from a private fork, custom domains, backups — see docs/DEPLOY.md.

Accessibility

plato is designed to be fully usable with screen readers (VoiceOver, NVDA, JAWS) and keyboard-only navigation. The AI chat follows the MITRE Chatbot Accessibility Playbook and Orange accessibility guidelines: silent-by-default chat log, controlled announcements for new messages, keyboard navigation between messages (Alt+ArrowUp/Alt+ArrowDown), and Cmd/Ctrl+Enter to send. Implementation details live in CLAUDE.md.

Contributing

Plugins live in plugins/ and have a lighter review bar — see docs/plugins/AUTHORING.md. Core changes (anything outside plugins/) follow CONTRIBUTING.md. The main branch is protected — all changes require a pull request.

License

Copyright (C) 2026 11:11 Philosopher's Group

This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License v3.0 as published by the Free Software Foundation. Modified versions that are accessible over a network must also be made available under the same license.