ΠΑΙΔΕΙΑ · Paideia _{for Hermes}

Your course. Your patterns. Your errors. Your cheatsheet.
A Hermes Agent plugin that turns your own materials into a permanent, editable, per-course study graph — every artifact shaped by you, not by a generic syllabus.

_{Original PAIDEIA coverage and interactive demo.}

한국어 README · taewoopark.com — author site

_{The PAIDEIA family — one study engine, every agentic runtime}

Platform	Repository	What it is
	PAIDEIA	The original — a Claude Code plugin.
	PAIDEIA-codex	OpenAI Codex skills + bundled MCP server.
	PAIDEIA-opencode	Command-line harness driving opencode.
	PAIDEIA-Hermes	Hermes Agent plugin: CLI commands + gateway routing.
	PAIDEIA-mcp	Standalone local MCP server — drive PAIDEIA from Alt local models.
	PAIDEIA-Alt	Exam Radar — the Alt lecture-capture plugin (altalt.org).

Generic study tools teach you the average syllabus. Paideia teaches you your syllabus —
from your professor's notes, your HW emphases, your handwriting, your errors. Every artifact is a markdown file you can edit.

What Paideia means

In ancient Greece, Παιδεία was never the deposit of facts into a passive student. It was the lifelong formation of a complete human being — through structured encounter with primary texts, guided practice under a master, and reflective dialogue that folds feedback into deeper revision.

This plugin implements that cycle for the specific, bounded problem of exam preparation in math, physics, and engineering courses:

  ingest ──▶ analyze ──▶ drill ──▶ grade ──▶ weakmap ──▶ cheatsheet
     ▲                                                        │
     └────────────────── feedback loop ───────────────────────┘

The study stages save Markdown artifacts in your course folder. You can keep reading, editing, and versioning those files independently of the agent. Generating new artifacts still requires the runtime, tools, and model used by the chosen stage.

What generic study tools can't do

Paideia starts with your course, your professor's assignments, and your mistakes. The input is the folder you bring: lecture notes, textbook chapters, homework, solutions, and scanned attempts.

Generic curricula and manually curated flashcards can be useful companions. Paideia adds a specific workflow: extract recurring moves from your solutions, rank practice by homework coverage, and feed recorded errors into the next drill. The table describes that workflow, rather than the features or subscription terms of every learning service.

Axis	Paideia	A generic course or an unstructured chat
Solution patterns (`P1..Pk`)	Extracted from your course's solutions, with source citations	Requires course-specific material and instructions
Drill priority	Weighted by your professor's HW emphasis	Must be selected and maintained separately
Cheatsheet	Errors shape the traps section; the course index supplies references	Must be assembled and revised separately
Per-course state across sessions	Markdown + metadata files in the course folder	Depends on the service and how context is supplied
Editing an artifact you disagree with	Open the `.md` in any editor and save	Depends on the tool's editing and export support
Carrying prep into another semester	Copy the course folder and revise the changed material	Requires moving the relevant material and history
Version history of your understanding	`git log` / `git diff`, when you commit the files	Depends on the tool's versioning support
Where the artifacts live	Your disk, as text	Depends on the service

The runner does the model work; the study graph remains yours to open, read, edit, and diff. Changing providers or pausing a subscription does not remove the files already produced.

Default answer OCR is claude: page images are read through the runner's vision path. For local answer OCR, install Ollama and qwen3-vl:8b, then explicitly select OCR_ENGINE: ollama in .course-meta or pass --ocr=ollama to grade. Downloading the model alone does not change the engine. tesseract is the other local option. Local OCR keeps that transcription step local; subsequent analysis and grading still use the configured model and may send it the transcribed text.

The load-bearing principle: HW density = exam probability

Homework is Paideia's primary signal for allocating exam-prep time. Sections with more assigned problems get more practice; sections without homework remain reference material by default. These are study-priority tiers, not measured probabilities or a guarantee of what the professor will test.

Tier	HW count on section	Treatment	Target share of mock-exam points
🔥🔥 Exam-primary	3+	Drill hardest	≥70%
🔥 Exam-likely	2	Drill next	~25%
🟡 Exam-possible	1	Warm-pass review	≤5%
⚪ Low-risk	0	Reference only	0 by default

/paideia quiz all, /paideia mock 90, and /paideia hwmap hot use this ranking. These allocations are instructions to the generating agent; inspect the resulting mock before relying on its exact distribution. Explicit requests and imported Exam Radar signals can inform what you choose to review.

The formation cycle, stage by stage

_{Actual macOS CLI sessions, viewed through a local terminal viewer. The course uses small synthetic demonstration materials. · Capture notes}

_{/paideia status — course · D-N · phase}	_{/paideia help — command reference}
_{/paideia init — course setup}	_{/paideia doctor — dependency check}

Start Hermes in the course folder and type /paideia <subcommand>. One slash command exposes 17 study/setup actions, plus help:

status, doctor, help, and init name="…" exam=YYYY-MM-DD … return Python-generated results directly.
Bare init hands an interactive setup wizard to the agent. The 14 study actions (ingest, analyze, drills, grading, reports, and alt) inject an agent turn; the initial “handed to the agent” line is an acknowledgement, not the completed artifact.
The agent reads the bundled command spec and skill files and writes results into the current course. You stay in the same conversation for a blind drill's strategy reply.
PAIDEIA registers a session-start banner and provides /paideia status. Open Markdown and equations in Obsidian alongside the CLI.

Stage	What it does	Commands	Produces
Encounter	Read the professor's signal	`/paideia ingest`	`converted/*/.md` — every lecture, textbook chapter, HW, solution, as clean LaTeX markdown
Structure	Extract the grammar of the course	`/paideia analyze`	`course-index/{summary,patterns,coverage}.md` — topic tree, recurring solution patterns (P1..Pk), HW-density exam-tier ranking
Practice	Active recall weighted by assigned homework	`/paideia quiz`, `/paideia twin`, `/paideia blind`, `/paideia chain`, `/paideia mock`	`quizzes/`, `twins/`, `chain/`, `mock/` — problems you solve on paper
Reflection	Your hand-written work becomes a grade	`/paideia grade`	`answers/converted/<name>.md` + `errors/log.md` — OCR via the agent's vision (default), Ollama/Qwen3-VL, or Tesseract; then strategy-based grading
Diagnosis	Errors compressed into a priority-ranked weakness report	`/paideia weakmap`	`weakmap/weakmap_<ts>.md` — append-only history
Distillation	One page, error-driven, printable	`/paideia cheatsheet`, `/paideia derive`, `/paideia pattern`	`cheatsheet/final.md`, `derivations/<slug>.md` — reference only what you actually need

Supporting: /paideia hwmap shows homework-based study priorities, /paideia status shows where you are in the cycle, /paideia init bootstraps a fresh course folder.

Slack & other messaging gateways

The plugin also registers pre_gateway_dispatch. On a configured Hermes gateway, messages such as !paideia quiz §1.2 3 (Slack/Matrix), /paideia quiz §1.2 3, or paideia quiz §1.2 3 can be rewritten into the same study prompt. This rewrite applies to the 14 model-driven study actions only.

status, doctor, help, and init fall through to the host's plugin-command handler. Use the explicit init name="…" exam=… form there: the bare wizard depends on CLI inject_message() and the gateway fallback can return the prompt text instead of starting a wizard. Gateway behavior also depends on the host exposing plugin commands on that platform.

Course paths are on the machine running the gateway. Agent-driven prompts use the agent's working directory; deterministic handlers and the banner use the Hermes process's Path.cwd(). Start the gateway in the intended course folder and align terminal.cwd with it. Setting only terminal.cwd does not redirect Python handlers. Upload or copy scans into that server-side course. The README screenshots show the CLI; they are not screenshots of a live Slack deployment.

Install

Prerequisites

Required

hermes-agent, on any provider (Nous Portal, OpenAI/Codex, Anthropic, OpenRouter, local, …).
Python 3.10+ (plugin syntax; the host may require newer) + a Unix-style shell (bash/zsh; WSL2 on Windows).
poppler (pdftoppm) — required by every OCR tier.
- macOS: brew install poppler tesseract tesseract-lang
- Linux (Debian/Ubuntu): apt-get install poppler-utils tesseract-ocr tesseract-ocr-kor
Python libs: pip install pdf2image pillow pytesseract reportlab pypdf pdfplumber. Only pdf2image and pillow are load-bearing — every OCR tier starts by rasterizing the PDF, so /paideia doctor reports those two as failures and the rest as warnings naming the one command each serves (pytesseract → the tesseract tier, reportlab → cheatsheet --pdf, pypdf/pdfplumber → ad-hoc PDF work).

Optional — only for --ocr=ollama (every page image stays on your machine)

ollama + qwen3-vl:8b (~6 GB). brew install ollama / install script, then ollama pull qwen3-vl:8b.

Run /paideia doctor any time to check all of the above (and /paideia doctor --fix to repair the permission-free ones). It probes the same python3 your agent's terminal uses, so it reports what the agent can actually run.

Install the plugin

hermes plugins install OPTIMETA/PAIDEIA-Hermes
hermes plugins enable paideia

Restart hermes; the /paideia command is now available in every session. Alternatives:

# B) git clone straight into the user-plugins dir
git clone https://github.com/OPTIMETA/PAIDEIA-Hermes ~/.hermes/plugins/paideia
hermes plugins enable paideia

# C) dev / local checkout (symlink — edits go live on the next session)
git clone https://github.com/OPTIMETA/PAIDEIA-Hermes && ./PAIDEIA-Hermes/install.sh

hermes plugins enable paideia records enablement in the active Hermes profile. Plugin discovery uses that profile’s plugins directory; HERMES_HOME can select an isolated profile.

Per-course bootstrap

Open hermes inside the folder you want to use for this course, then either run the wizard:

/paideia init

…or scaffold non-interactively in one line:

/paideia init name="Complex Analysis MATH 405" exam=2026-12-15 type=final lang=en ocr=claude weak="contour integration"

Either form collects the same six fields — interface language en|ko, COURSE_NAME, EXAM_DATE, EXAM_TYPE, USER_WEAK_ZONES, and the OCR engine — and both run the same scaffolding: the directory skeleton, .course-meta, a project PAIDEIA.md, a .gitignore that excludes archived scans and OCR scratch, and a seeded errors/log.md. A malformed exam= date is rejected rather than scaffolded, since a course whose countdown never appears gives you nothing to notice.

Scaffolding does not initialize Git. Run git init and commit the files if you want version history; add an answers/*.pdf ignore rule if active scans should also stay untracked. Re-running init refreshes .course-meta and preserves existing PAIDEIA.md and error history.

The wizard also runs a dependency check first; after the one-liner, run /paideia doctor yourself. Override the OCR engine for a single grade with /paideia grade --ocr=claude path/to/answer.pdf.

Course folder layout

After /paideia init, your course folder looks like this:

my-course/
├── .course-meta                     # course name, exam date, interface language (en|ko), OCR engine
│                                    #   one KEY: value per line, safe to hand-edit;
│                                    #   a `# comment` needs two spaces before it,
│                                    #   so `Complex Analysis #2` stays a course name
├── PAIDEIA.md                       # per-course workflow context the agent reads
├── .gitignore                       # excludes archived scans + OCR scratch; active answer PDFs need your own ignore rule
│
├── materials/                       # YOU DROP RAW FILES HERE (PDF or MD)
│   ├── lectures/  textbook/  homework/  solutions/
│
├── converted/                       # generated Markdown — back up edits before re-ingest (output of /paideia ingest)
│   ├── lectures/  textbook/  homework/  solutions/
│
├── course-index/                    # knowledge base — built by /paideia analyze
│   ├── summary.md                   # topic tree (§1, §1.1, §2, …)
│   ├── patterns.md                  # recurring solution patterns, labeled P1, P2, …
│   ├── coverage.md                  # HW ↔ § map with 🔥🔥 / 🔥 / 🟡 / ⚪ exam tiers
│   └── radar.md                     # lecture-emphasis signal — imported by /paideia alt
│
├── answers/                         # YOU DROP HAND-WRITTEN SCAN PDFs HERE
│   └── converted/                   # /paideia grade writes OCR'd markdown here
│
├── errors/log.md                    # append-only YAML error log (seed for /weakmap + /cheatsheet)
│
├── quizzes/                         # /paideia quiz — each problem has a hidden _answers.md sibling
├── mock/                            # /paideia mock — full mock exams (hidden _sol.md siblings)
├── twins/                           # /paideia twin — same pattern, new surface
├── chain/                           # /paideia chain — multi-pattern integration problems
├── derivations/                     # /paideia derive — clean reference derivations
├── cheatsheet/                      # /paideia cheatsheet — error-driven one-pager (+ optional PDF)
└── weakmap/                         # /paideia weakmap — timestamped, append-only history

Drop source files in materials/ and answer scans in answers/. All Markdown artifacts are editable; generation can overwrite derived files, so commit edits you want to preserve. Keep errors/log.md and the weakmap history: they record personal attempts that cannot be reconstructed from the source PDFs alone. Runtime context files and OCR engine names differ between editions; see the migration FAQ.

A reading tip: use Obsidian

Paideia writes everything as plain markdown with LaTeX math ( $...$ , $$...$$); you can read it in any editor, but Obsidian is the natural choice:

Renders $...$ and $$...$$ math via MathJax with zero configuration.
Backlinks let you click from quizzes/q_<ts>.md straight into the cited converted/lectures/chN.md §K.
The whole course folder is just a vault — point Obsidian at ~/courses/my-course, and everything is a searchable graph. Offline, free, local — consistent with Paideia's philosophy.

The terminal is bad for math; don't fight that.

And the lecture end: Alt

Obsidian is the companion at the reading end. Alt is the companion at the other end — where the lectures come in. Alt records and transcribes your lectures, and OPTIMETA's Exam Radar plugin runs inside it to rank topics by how strongly the professor emphasized them out loud. Send that into Paideia with /paideia alt, and the loop closes: attend the lecture → capture it → extract the exam signal → study what matters.

Full workflow — an example

Phase 0 — once per course (15 minutes)

cp ~/textbooks/ch*.pdf      ~/courses/my-course/materials/textbook/
cp ~/lecture-notes/wk*.pdf  ~/courses/my-course/materials/lectures/
cp ~/hw/hw*.pdf             ~/courses/my-course/materials/homework/
cp ~/hw/hw*_sol.pdf         ~/courses/my-course/materials/solutions/

In Hermes:

/paideia ingest                     # every PDF → vision pipeline (parallel agents, LaTeX-faithful)
/paideia analyze <weak-zone hints>  # build patterns + coverage + summary
/paideia hwmap hot                  # surface 🔥🔥 exam-primary zones

Phase 1 — diagnostic (40 minutes)

/paideia quiz all 20                # broad diagnostic, 20 problems
# solve on paper (40 min), scan to answers/diagnostic.pdf
/paideia grade                      # selected OCR engine + strategy grade

Phase 2 — targeted drilling (bulk of your prep time)

/paideia weakmap                    # priority-ranked weakness report
/paideia blind hw3-p2               # strategy-only drill on a known problem
/paideia twin hw3-p2                # variant with same pattern, new surface
/paideia chain 3                    # multi-pattern integration problem
/paideia quiz weakmap 5             # 5 problems targeting the latest weakmap

Phase 3 — integration (~90 minutes)

/paideia mock 90                    # full 90-min mock weighted by HW density
# solve on paper, scan, upload to answers/mock_<ts>.pdf
/paideia grade                      # grade the mock

Phase 4 — compression (60 minutes, night before exam)

/paideia cheatsheet --pdf           # error-driven one-pager
/paideia weakmap                    # review weak zones one more time

Phase 5 — cool-down (10 minutes before exam)

/paideia weakmap                    # top 3 only. Do not learn new things.

Commands (17 total)

This is the installed command inventory for this edition. It does not include the original's reindex or graph commands.

/paideia <subcommand> [args] — run /paideia help for the list inline.

Command	Purpose
`/paideia init [name=… exam=… …]`	Bootstrap a fresh course folder (wizard, or one-line with args)
`/paideia doctor [--fix]`	Diagnose the install + workspace; `--fix` repairs permission-free issues
`/paideia status`	One-line `course · D-N · phase · top-miss pattern`
`/paideia ingest [--force]`	Every PDF in `materials/` → markdown in `converted/` (subagent per PDF, LaTeX-faithful)
`/paideia analyze [hints]`	Build `course-index/{summary,patterns,coverage}.md`
`/paideia hwmap hot\|<§>`	Surface 🔥🔥 Exam-primary sections ranked by HW density
`/paideia pattern <§\|Pk\|keyword>`	Show pattern cards from course-index
`/paideia derive <target>`	Clean reference derivation to `derivations/<slug>.md`
`/paideia quiz <topic\|§\|weakmap> [N]`	N practice problems, answers hidden in a sibling `_answers.md`
`/paideia blind <problem-id>`	Strategy-check drill on a known problem (describe approach, no re-solve)
`/paideia twin <problem-id>`	Variant of a known problem — same pattern, new surface
`/paideia chain <N>`	Multi-pattern integration problem combining N patterns
`/paideia mock <minutes>`	Full mock exam, HW-density weighted
`/paideia grade [--ocr=<engine>] [path]`	OCR an answer PDF, strategy-grade, append `errors/log.md`
`/paideia weakmap [concept]`	Priority-ranked weakness report → `weakmap/weakmap_<ts>.md`
`/paideia cheatsheet [--pdf]`	Error-driven one-pager
`/paideia alt [paste]`	Import an OPTIMETA Exam Radar (Alt) export → `radar.md` + a lecture-emphasis column on `coverage.md`

Under the hood

Ingest pipeline: vision for every PDF

PDFs are rendered into page images before transcription. Markdown sources are copied with a provenance header. Ingest writes the converted material; analyze then creates summary.md, patterns.md, and coverage.md from those sources.

pd_render.py streams one page at a time, using 160 dpi and a maximum 1800 px long edge for ingest. The command spec asks Hermes to delegate one PDF per agent, with sequential page reading. The selected model and available tools determine whether that agent workflow can run.

Ingest always follows the agent-vision specification. The OCR_ENGINE choice below controls answer grading; selecting ollama does not reroute /paideia ingest to local OCR. Plain Markdown sources do not require image recognition.

Hand-writing OCR: three engines, you pick

Solve on paper, scan to answers/, then run /paideia grade. Engine choice is per course and can be overridden with --ocr=<engine>.

Engine	Default?	How it runs	When to pick it
`claude`	Yes	Render pages, then read them through the agent's vision path.	A working vision-capable model/tool configuration.
`ollama`	Optional	Local Ollama `qwen3-vl:8b`, with Tesseract fallback.	Keep the answer's OCR page images local.
`tesseract`	Optional	Local `pytesseract`.	Typed scans; handwriting and math need careful review.

Default answer OCR is claude: page images are read through the runner's vision path. For local answer OCR, install Ollama and qwen3-vl:8b, then explicitly select OCR_ENGINE: ollama in .course-meta or pass --ocr=ollama to grade. Downloading the model alone does not change the engine. tesseract is the other local option. Local OCR keeps that transcription step local; subsequent analysis and grading still use the configured model and may send it the transcribed text.

claude is a legacy engine label retained by this port. It means the Hermes agent vision workflow; it does not choose Anthropic or switch the configured model. pd_vision_ocr.py implements only the local tiers; the command spec handles native vision.

Strategy-based grading, not line-by-line

The grading instructions check (1) the selected pattern Pk, (2) the variables, substitution, basis, or contour, and (3) the final expression's form. Review the transcription and grade when OCR is uncertain. Errors are appended to errors/log.md using problem_id, pattern, error_type, summary, source, and date. Error types include pattern-missed, wrong-variable, wrong-end-form, algebraic, sign, and definition.

The cheatsheet uses the course index and error history together: patterns/formulas provide reference material, while your errors drive the traps and corrections. --pdf also requests a printable cheatsheet/final.pdf; inspect the rendered equations before printing.

Patterns extracted from your solutions

/paideia analyze reads the course's solutions and worked examples, labels recurring moves P1, P2, …, and cites the source files under converted/. The resulting pattern cards and HW coverage are the context for later drills. The model-generated index should be checked against your assignments.

Append-only history

Commands append attempts to errors/log.md and save dated reports under weakmap/. Keep that history when re-ingesting or migrating. Generated problem sets have separate answer/solution siblings; solve the problems before opening them.

Status and the session banner

/paideia status reports course · D-N · phase · top-miss. The detector uses setup when patterns.md is absent; diag when patterns exist without both a quiz problem and a recognized error entry; drill once both exist; mock after a recognized mock-sourced record; cram when cheatsheet/final.md or .pdf exists; and cool on exam day. The latest weakmap's first pattern is preferred, with error-log frequency as fallback. This is a filesystem heuristic, not evidence of mastery.

Hermes also registers an on_session_start banner. The hook is silent outside a course; an explicit /paideia status there returns setup guidance.

What ships

PAIDEIA-Hermes/                     # == ~/.hermes/plugins/paideia/
├── plugin.yaml                     # manifest (name, version, hooks)
├── __init__.py                     # register(ctx): /paideia command + on_session_start + pre_gateway_dispatch
├── pd_meta.py  pd_workspace.py  pd_errlog.py  pd_weakmap.py    # deterministic engine
├── pd_status.py  pd_banner.py  pd_doctor.py                    # status / banner / diagnostics
├── pd_render.py  pd_vision_ocr.py                              # PDF→PNG + offline OCR tiers (run standalone)
├── pd_prompts.py  pd_commands.py                               # inject-prompt builder + /paideia dispatcher
├── tests/                          # stdlib-only regression suite — ./tests/run.sh
├── commands/                       # 15 agent-facing command specs (.md)
├── skills/
│   ├── paideia-pdf/{SKILL.md,VISION.md}        # vision ingest pipeline
│   ├── paideia-vision-ocr/SKILL.md             # the agent's vision + Ollama + tesseract
│   ├── paideia-course-builder/SKILL.md         # ingest + analyze
│   ├── paideia-exam-drill/{SKILL.md,twin-recipe.md}
│   ├── paideia-answer-processing/SKILL.md      # strategy-grade OCR output
│   └── paideia-alt-import/SKILL.md
├── install.sh  LICENSE  CHANGELOG.md  README.md  README.ko.md

Run the tests before sending a patch — no install step, no pytest, no venv:

./tests/run.sh          # 98 tests, runtime varies

They cover the deterministic engine end to end and pin the cross-file contracts that would otherwise drift silently: pd_doctor.py deliberately keeps its own standalone copies of the directory skeleton, the meta keys and the error-log seed, and every LLM subcommand must have both a command spec and a skill that exists on disk.

Four of them check that errors/log.md stays valid YAML under fuzzing, which needs a YAML parser. Without one they skip and the run reports OK (skipped=4) — so pip install pyyaml if you are touching pd_errlog.py, or that "OK" is quieter than it looks.

How it maps to hermes' extension surfaces:

PAIDEIA (Claude Code)	PAIDEIA-Hermes (hermes-agent)
`/paideia:*` namespaced commands	one `/paideia` slash command + subcommand dispatch (`ctx.register_command`)
auto-loaded skills	`skills/paideia-*/SKILL.md`, read by absolute path from the inject prompt
in-session command runs the `.md` directly	handler `inject_message()`s a turn (CLI) / `pre_gateway_dispatch` rewrite (Slack/Discord)
`SessionStart` hook banner	`on_session_start` hook
`statusLine` hook	`/paideia status` + the session banner
parallel ingest agents	hermes subagent delegation (one per PDF)
`CLAUDE.md` per course	`PAIDEIA.md` per course

Design convictions

Read the math as Markdown. Open the course in Obsidian or a Markdown-capable desktop view.
Solve on paper. Scan the answer and choose the OCR path that fits your setup.
Review strategy and transcription. Pattern, variables, and final form guide grading; OCR and model judgments can need correction.
Extract patterns from your course. Cite the supplied solutions and worked examples.
Learn from recorded errors. Let them shape practice and the cheatsheet's traps.
Use homework to prioritize. Treat its density as a study signal and check it against the announced exam scope.
Keep the study graph yours. Editable Markdown, preserved error history, and version control across sessions.

FAQ

Does this work for non-math courses? Ingest and summarization can help, but the practice workflow assumes recurring problem-solving patterns. It is designed for math, physics, engineering, and related quantitative courses.

How does the next session remember my work? The course context, index, and error history are files. Later commands read them again; your study record is not dependent on chat history alone.

Can I edit the patterns or cheatsheet? Yes. Save changes in any Markdown editor and commit the files you want to preserve before regenerating them. Keep the error log and weakmap history.

Korean and English mixed materials? Set INTERFACE_LANG: en or ko in .course-meta for the generated narrative. File paths, pattern IDs, YAML keys, and tier tokens stay unchanged. The local OCR helper uses the corresponding Tesseract language configuration; install the needed language packs.

Do I need Ollama, and is the whole workflow offline? Ollama is optional. The default uses the runtime’s vision path. Local OCR keeps image transcription on your machine, but analysis and grading still use your configured model. See the OCR engine table above for the required setup.

Can I move a course between PAIDEIA editions? The Markdown study artifacts share a layout. Review the destination's context file and engine names first: CLAUDE.md / AGENTS.md / PAIDEIA.md, and claude / codex-native / vision or ollama / qwen3-vl. Preserve your existing metadata and personal history; the versions do not have identical configuration or command sets.

Does model-generated grading need review? Yes. The source scan, transcription, referenced patterns, and YAML log let you inspect and correct an assessment. The status indicator is a file-based workflow cue, not an independent measurement of understanding.

Connect

License

MIT. PAIDEIA-Hermes is a hermes-agent port of OPTIMETA/PAIDEIA and carries the same license and copyright (© 2026 Taewoo Park); see LICENSE. Use freely — fork and modify for your own courses. The point of the plugin is that the study graph it builds is yours to shape, not a fixed product you have to live with.

Credits: the original PAIDEIA (Claude Code) and the host platform NousResearch/hermes-agent (MIT).

Generic curricula teach the average student. Παιδεία — formation, one student at a time.

Name		Name	Last commit message	Last commit date
commands		commands
docs/media		docs/media
skills		skills
tests		tests
.gitignore		.gitignore
CHANGELOG.md		CHANGELOG.md
LICENSE		LICENSE
README.ko.md		README.ko.md
README.md		README.md
__init__.py		__init__.py
install.sh		install.sh
pd_banner.py		pd_banner.py
pd_commands.py		pd_commands.py
pd_doctor.py		pd_doctor.py
pd_errlog.py		pd_errlog.py
pd_meta.py		pd_meta.py
pd_prompts.py		pd_prompts.py
pd_render.py		pd_render.py
pd_status.py		pd_status.py
pd_vision_ocr.py		pd_vision_ocr.py
pd_weakmap.py		pd_weakmap.py
pd_workspace.py		pd_workspace.py
plugin.yaml		plugin.yaml

Latest commit

History

Folders and files

Repository files navigation

ΠΑΙΔΕΙΑ · Paideia for Hermes