Included with IVYX Studio

A notebook that will not let you nod along

Real lessons, run against a real kernel, gated so the first thing you do is think.

Every graded cell in a published course fails in the state it ships. You say what a cell will print before the run button opens, you open hints one rung at a time, and a concept counts as mastered only after a pass with no help and no scaffold. All of that lives inside the lesson file, so the same file still opens as a plain notebook anywhere else.

Browse the catalog Download IVYX Studio

"ivyx": {
  "role": "exercise",
  "concepts": ["sorting"],
  "predict": { "prompt": "What will this print?", "check": "llm" },
  "gate": { "solutionAfterAttempts": 2 },
  "hints": [{ "level": "nudge", "text": "..." }],
  "diagnose": { "rationale": "...", "pitfalls": ["..."] }
}

A lesson is a standard notebook named *.lesson.ipynb. The teaching sits under metadata.ivyx, which nbformat ignores, so Jupyter and the professional notebook editor open the same file and simply do not show it.

Getting started

Three steps, once. After that a course is a folder in your workspace.

1. Install Learn and a lab

Learn owns the teaching: the lesson format, the gates, the hint ladder, the learner model and the tutor. Notebook Lab runs the cells. Without Learn a lesson does not open at all, because a lesson with its gates quietly switched off is not a lesson.

2. Get a course

Course Market searches published courses, shows the level, length and lesson count on the card, and downloads one into your workspace. It arrives as ordinary notebooks plus a small manifest naming the modules and their order. Nothing is hidden or locked.

courses/<slug>/
├── .course.json
└── lessons/*.lesson.ipynb

3. Open the Learn window

The sidebar groups every lesson file in the workspace into courses and modules and keeps your place between sessions. A lesson you wrote yourself in a folder shows up the same way, with no manifest and no download.

Learn ↗    *.lesson.ipynb

What a lesson needs

A Python kernel for lessons that run code, and a connected MCP server for lessons that test one. A language model is optional: without it the gates, the authored hints and the cells all still work, and only the conversation goes quiet.

How a lesson runs

The same five moves on every graded cell. None of them depend on a model being attached.

1
Predict
Where a cell carries a prediction, the run button stays shut until you submit one. Submitting is what opens it; being right is a separate matter, and a missing model never wedges the button closed.
2
Run, and fail
Every graded cell in a published course is authored to fail as it ships. The blank is a syntax error until you fill it, the exercise raises, and the challenge uses names you have not defined yet. A cell that runs clean on the first press teaches nothing.
3
See what you said
After the run, your prediction and the real output sit side by side. It is mounted on failure too, because expecting a cell to work and watching it raise is a broken model worth seeing.
4
Open a hint, one rung
The first rung the author wrote is showing; deeper ones wait behind an explicit reveal and behind the attempt counts. Choosing to open one is itself recorded, before its text is on screen.
5
Get diagnosed after passing
The one check an autograder cannot do. After a cell passes, the lesson names the reasoning it was meant to demonstrate and the known ways to land on the right answer without it. A right answer for the wrong reason takes the green back.

The defaults

Step by step: after 1 failed attempt
Worked solution: after 2 failed attempts
Prediction first: on any cell that asks for one

Gates belong to the lesson and the cell, not to your install, and a cell's own setting always wins over the lesson policy. What unlocks is decided by pure functions with no model, no clock and no network in them, because one more attempt has to mean exactly one more attempt.

The hint ladder

Four rungs, written by the author. A rung nobody wrote never appears, and teaching mode opens all of them.

1/4

Nudge

Available from the first attempt. A student who can see no way forward at all is not struggling productively.

2/4

Concept

Also from the first attempt. It names the idea the cell is about without touching this cell's answer.

3/4

Steps

Held back until an attempt has failed. Reaching for step by step help is the definition of stuck, so the strip records it as such.

4/4

Solution

The last rung, and it can be marked explain only: it explains the fix and never emits the code. A redaction pass enforces that afterwards, because a prompt rule that holds most of the time is not a gate.

The tutor

It follows the cell you have selected and answers with a question rather than a patch.

It reframes and asks

One reframe and one leading question per turn. Separate instruction classes grade a prediction, compare it against what really happened, adapt an authored hint to your attempt, and diagnose a passing run.

It goes through the same gate as everything else

Every call is a capability call through the runtime gateway, so the tutor inherits your policy, your approvals and the audit trail. It never holds a provider handle of its own.

You can read what it was told

The prompts are YAML files in your workspace under .punica/instruction-classes, so an instructor can read and change what the tutor is allowed to say without touching any code.

.punica/instruction-classes/*.ic.yaml

No model attached is not an error state. Every tutor call simply returns nothing, and the lesson keeps working on its deterministic half: the gates, the hints written into the file, and real cells against a real kernel.

What mastered means

Following a worked solution and watching the cell go green is the illusion this product exists to break, so an assisted pass stops short of mastery.

Unseen: Declared and untouched. Not the same as failed, and never coloured as though it were.
Learning: Seen, or passed with help. Progress, not proof.
Stuck: Two failures in a row, or you opened the step by step rung or the solution.
Mastered: An unassisted, first attempt, unscaffolded pass. A later failure takes it back, because it is a claim about the present tense.

Where your progress lives

One JSON file in the workspace, under .punica/learn. It is never written back into a lesson file: a lesson is authored content that several students open, so nothing in the format has a slot for your attempts. Re-downloading a course replaces the notebooks and leaves what you learned alone.

.punica/learn/progress.json

Writing a lesson

The same product in a different mode, rather than a separate authoring tool.

Teaching mode

The switch in the lesson header lifts every gate, opens every rung, and replaces the tutor panel with a form for the selected cell: the hints, the gate counts, the concepts it is evidence about, the prediction and the diagnosis. You are editing the notebook you are looking at.

A folder is a course

A folder of *.lesson.ipynb files needs nothing else. The course tree is read from the files themselves, which is how every course starts. A course published to the market also carries a manifest, and that manifest is the authority on titles, grouping and order while the lesson file stays the authority on the teaching.

Read a course before you take it

Course Explorer opens the same drawer for a course in the market and one already in your workspace: the goal, the outcomes stated as things you will be able to do, who it assumes you are, every lesson on the way with its own goal and length, and what it needs to run. It writes no file and reaches no network of its own.

For ages 10 to 14

IVYX Learn Junior is the same idea for middle school: four missions that teach a child how a computer learns, with a guide called Pixel that asks instead of answering.

Missions, not chapters

Each one ends in a badge the child earns rather than collects: a short story about one idea, a few questions with a hint that never names the option, and then a real experiment.

A sorter you can break

The child teaches a picture sorter from a handful of photos and watches how sure it gets, finds the photo in the wrong group, and then shows it a green apple after it has only ever seen red ones.

Nothing leaves the machine

The missions, the quizzes and the example photos ship inside the extension, nothing is downloaded, and the conversation never leaves the computer. Progress, badges and time used are in a grown-ups view.

File › New Junior Window

What it does not do yet

One learner per workspace

Progress belongs to whoever has the workspace open. There is no learner identity yet, so two students on one machine share one record.

The cohort view is sample data

The instructor view of what a class is stuck on reads seeded rows today and says so on every screen. The service behind it is the next phase, and the view does not change when it arrives.

Hints are in the file

The ladder and the worked solutions live inside the lesson notebook, so a determined student can open them in a text editor. That is acceptable for classroom use and it is the other thing the cohort service fixes.

The tutor panel is not gated

The ladder is metered by attempts; the conversation beside it is not, and its turns are not recorded. Read the ladder as pacing, the order in which ideas arrive, rather than as access control.

Finishing is not proving

A lesson is finished when every runnable cell has passed. Proving it needs a concept mastered, and since the first attempt is a designed failure, most lessons today end finished and unproven. The sidebar draws those differently on purpose.

The contract is checked where the courses live

Published courses are executed against a real kernel before release, and every graded cell has to fail as shipped and pass against its reference solution. A course authored outside that repository gets none of those checks.