Studio · The Nodes Engine

Course Engineering ends by generating a Mastery Node — but a node isn't content yet, it's a target. The Nodes Engine takes each node through five production steps, turning that target into the finished, packaged experience the runtime serves.

The 30-second version

The Node Engine runs five SME-approved steps: node generation → experience blueprint → content specification → modality production → validation & review. Design comes before production, across three artifacts (the Mastery Node, the Node Experience Blueprint, the Node Learning Package), so a change of modality or scenario never wastes finished content. An LLM Council reviews the design and the produced content in two separate passes, with an SME gate at each.

For engineers — the three objects, and what you receive

Studio separates three objects that developers must not conflate: the Mastery Node (what must be learned — the academic/adaptive target), the Node Experience Blueprint (how it will be experienced — a design object), and the Node Learning Package (what the learner actually sees — produced content). Your runtime consumes the produced package (Level 3 objects in a common envelope), plus the blueprint (Level 1) and content specs (Level 2) as the source-of-truth. Data-model sketches for all three appear in the Published Course Package.

The five production steps

The Node Engine is the second Studio phase. Like Course Architect, every step is an SME gate.

1 · Node generation→ 2 · Experience blueprint→ 3 · Content specification→ 4 · Modality production→ 5 · Validation & review

Step	Produces	In one line
1 · Node generation	The Mastery Node (with its DNA)	Decompose a subtopic into diagnosable units, each targeting one Knowledge Component.
2 · Node Experience Blueprint Level 1 · design	The design	The ordered learning objects, a modality per object, the Evidence Check design, and adaptive branches.
3 · Content Specification Level 2 · design	The grounded per-object spec	Exactly what each object must contain — the academic source-of-truth, preservation rules, grounding references.
4 · Modality Production Level 3 · produce	The real assets	The actual text, video, interactive, or structured visual the learner consumes, produced from the spec.
5 · Validation & Review	The consumable package	Governance and fidelity checks, then assembly into the Node Learning Package the runtime consumes.

Design first, then produce

Steps 2–3 are design (Phase A); an SME approves before anything is produced. Steps 4–5 are production (Phase B). Designing before producing means a change of modality or scenario never wastes finished content. The node-first philosophy underneath: Maestro does not generate a lesson and slice it into modalities — it assembles a node-based experience outward from the mastery target.

What a node is

A node is not a video, a reading, a page, a quiz, a slide deck, or a week. A Maestro Mastery Node is a decision-ready unit of mastery: a focused unit targeting one Knowledge Component (KC) — a single concept, skill, judgment, or misconception — that Maestro can make an educational decision around. It wraps a small experience around that target (orient → teach → practise → prove) and ends in an Evidence Check.

A weak node is a topic label ("Evaluation criteria"). A strong node states an action that can generate evidence ("Evaluate strengths and limitations of a curriculum framework using evidence-based criteria"). Nodes connect by prerequisite, bridge, and threshold relationships to form the course's learning graph — the structure routing traverses at runtime.

The eleven node types

The node type is the cognitive job the node does. It is the single most load-bearing piece of metadata: it drives the modality, the evidence, and the feedback downstream. A course uses whichever types fit its outcomes.

Node type	Purpose
Concept	Understand an idea or principle.
Distinction	Separate two ideas learners habitually confuse.
Misconception	Surface and repair a specific wrong belief.
Procedure	Carry out a process or method correctly.
Judgment	Make a reasoned, criteria-based decision.
Application	Use knowledge in a real or realistic context.
Integration	Combine several prior nodes into a coherent whole.
Reflection	Build professional self-awareness and metacognition.
Threshold	Cross a transformative shift in how the discipline is seen.
Bridge	Transition from one learning territory to another.
Assessment preparation	Consolidate mastery into readiness for the summative artifact.

Design vs runtime

The model defines all eleven types. The first vertical slice (CLO1-ST1 in MDLD602) only used four — Distinction, Concept, Application, Bridge — because that one subtopic only needed those. The full palette is what Studio can generate; see Status for what the runtime implements today.

The Experience Blueprint (Level 1)

The Node Experience Blueprint answers "how will this node be experienced?" It is a design object, not produced content. It emits an ordered set of learning objects (the design blueprint also calls these "blocks") — and for each: sequence order, purpose, modality, learner action, evidence role, adaptive trigger, and estimated time. It also carries the Evidence Check design: the evidence map, the four signals to capture, which misconceptions the check must detect, and the confirming-probe variant for high-risk misconceptions.

For engineers — the blueprint is structured data

Treat the blueprint as a contract. Each object declares sequence, block_type, purpose, recommended_modality, learner_action, evidence_role (none | practice | readiness | feedback | remediation | enrichment), adaptive_trigger (always | not_ready | partially_ready | ready | advanced), and estimated_time_minutes. Production fills each object with content — it does not change the design. The blueprint travels in the course package alongside its produced objects.

Content Specification (Level 2)

Between design and production sits the Content Specification: the grounded, per-object academic source-of-truth. It states exactly what each object must contain — the required explanation, the examples, the preservation rules (what must not be simplified away), and the grounding references back to the reference corpus. Level 2 is what a producer — and later the AI Companion at runtime — is allowed to compose against. It is the boundary that keeps produced content and live guidance academically anchored.

Modality Production (Level 3)

Level 3 is the actual asset the learner consumes, produced from the spec. Each produced object is wrapped in a common envelope carrying its identity, parent references, purpose, produced modality, content, grounding references and strength, the prompt-template ID and version used, generation mode, governance status, an asset reference, and a fidelity-check block. Versioning is part of the envelope, not an afterthought.

For engineers — produced modality enum

produced_modality ∈ text · structured_visual · pictorial_visual · video · interactive · simulation · learning_anchor. Simulations are architecturally recognised but deferred as a runtime engine for release one. The learning_anchor vehicle is what the Companion composes against. In the first runtime slice, produced_modality is text | video and interactive ships as a text-equivalent — see Status.

Modality — the palette & roles

Modality is never chosen by learner preference — that is discredited "learning styles" thinking. It is selected from the node's type of mastery: the question is always "what best supports THIS learning need?" A judgment node needs a scenario; a distinction node needs a comparison; a concept node may need only a short explainer.

When the Node Engine produces a learning object it takes one of five concrete forms. Four carry academic claims and are grounded and approved; one is mood-only and never teaches:

Modality	What it's for	Academic claims?
Text	Core teaching — orientation, explanation, remediation.	Grounded & approved
Video	Bringing key explanations to life in a richer format.	Grounded & approved
Interactive	Letting learners apply, practise, and prove mastery.	Grounded & approved
Structured visual	Diagrams, charts, tables that carry meaning — comparisons, criteria, steps, frameworks.	Grounded, labelled & approved
Pictorial visual	Atmosphere, metaphor, scene-setting — no teaching text.	Mood only — no claims

A node doesn't have one modality — it has modality for three moments:

Role	When it plays	Example
Learning modality	The core encounter with the idea.	scenario, explainer, worked example…
Remediation modality	When the learner is Not Ready / Partially Ready.	contrastive examples, a sentence frame, a route back to a prerequisite
Enrichment modality	When the learner is Advanced.	apply in a new context, an optional Mastery Credit challenge

Learning objects in a node

Inside a node, modality is applied object by object. The blueprint lays out an ordered sequence — this is the backbone, though not every node uses every object, and remediation and challenge branches hang off the evidence step:

orientation→ activation→ explanation→ modeling→ practice→ evidence→ feedback→ next action

The logic reads left to right: prepare the learner, teach, let them practise, collect evidence, respond, and route onward. Each object also carries an evidence role — some objects are pure teaching, one is the Evidence Check that produces the diagnosis (the subject of the next topic), and others exist only on a remediation or enrichment branch.

MDLD602 — a node's object sequence

For the node "Evaluate strengths and limitations of a curriculum framework using evidence-based criteria" (a judgment node): orientation → prerequisite activation (description vs opinion vs evaluation) → 3-min core explanation → worked example (weak vs strong) → practice (pick the strongest evaluation) → evidence checklist → evidence task (write an evaluation) → feedback, with a remediation branch (contrastive example + guided rewrite) and a partial-readiness branch (targeted prompt) hanging off the evidence step.

Validation & review

The final step folds fidelity checks and governance into assembly. The LLM Council reviews in two passes — Pass 1 on the blueprint (before content is produced), Pass 2 on the produced content — each consolidated by a Chairman and gated by an SME. Multiple reviewers examine the same object through different lenses, so blind spots don't travel:

Council lens	Checks
Pedagogical Designer	Learning progression and scope.
Discipline / SME	Academic accuracy and level.
Assessment Evidence	Whether the task truly proves mastery.
Adaptive Feedback	Readiness states, remediation, challenge.
Learner Experience	Clarity, motivation, cognitive load, trust.
AI Integrity	Whether the task can be passively outsourced to AI.
Accessibility & Inclusion	Access, language, inclusivity.
Diagnostic Reliability	Whether we can trust what the system concluded about the learner.

The output of the whole engine is the Node Learning Package: the validated, packaged content the runtime consumes. From here the work crosses into the Published Course Package and on to the Adaptive Learning System — but first, the piece that makes a node adaptive at all: the Knowledge Check.