Everyone is making AI better at answering. We taught ours when not to.
The better an AI answers, the less a student has to think. So the engineering goes somewhere else: making a course pace itself like a teacher, training an agent to hold back, letting several agents share one project, routing support by stage and withdrawing it on time, and making every sentence of the final assessment checkable. The pedagogy is settled first; the algorithms implement it.
The pedagogy is decided first. The algorithms implement it.
Each of the five below started as a claim about teaching and only then became an implementation. They're in the order a student meets them: learn the method inside a course, carry it into a project, and have the assessment read the whole thing back at the end.
Human-like course workflow
A course isn't a video with questions bolted on. It paces itself the way a teacher does: show the material, wait, ask about that material, hand over a card where she gets stuck, wait for her answer, then decide where to go. What she answers changes the route ahead.
The outcome of a course is capability and the deliverable is a handful of methods she can carry into real coursework — she leaves with tools in hand, not with watch time.Education-enhanced AI agent
A general assistant's instinct is to complete the answer. This one asks itself something first, every turn: who should be doing the thinking right now. It answers when answering helps, nudges when a nudge is enough, and hands a thinking card back when the thinking is hers — one question at a time.
This is the line schools care about most: the AI is present throughout, and the prose and the core judgment stay hers. The system holds that line, rather than leaving it to everyone's good intentions.Multi-agent assistance
A project runs for weeks. The main agent walks framing, reading, writing and review with an unbroken memory; only work that must swallow a long text — reading a paper, assessing a whole process — goes to a context-isolated sub-agent, which comes back with conclusions only.
It carries the multi-week work — EE, IA, a research project. And that's exactly the work in which judgment becomes visible: a short task can't show you whether someone can think.Staged AI support
“Let me take a look at that” is help while she's framing a question and ghost-writing once she's drafting. So support is routed by stage: what the AI may and may not do is defined separately for each one. And support has to withdraw — a card has succeeded when it stops being summoned.
A teacher can hand the AI to a class without hesitating: the boundary is written into the system, so it doesn't depend on repeated reminders or on somebody standing over them.Process evaluation
At the end the whole process gets read back into a report. Whatever can be counted computes straight from the record. Whatever takes judgment must point at a fragment that actually exists — click it and there's the conversation, the card, the source.
For the first time the thinking itself is something you can produce: teachers see the evidence, families read the narrative, a student sees her own trajectory — and a school finally has a second kind of proof beyond the finished work.A course runs on a teacher's pacing, not on a progress bar
A video only knows how to keep playing. Here a slice is a workflow: every step includes waiting for her, and what she does changes what comes next. A course-authoring agent writes the content; playback is fully determined — two students can end up in different places, and neither can end up somewhere broken.
Every step waits for her
The course moves on after she's watched, answered, filled the card in. Waiting is the one thing a video can't do — and it's the beat that matters most in teaching.
Her answer changes the route
Answer solidly and it moves on; answer vaguely and it comes at the question from another side; get stuck and a card arrives. The branches are written into the course, so the path through it is her own.
The opening and the ending are written for her
The first line shouldn't be the same for a student who just traced a source and one who just abandoned a lead. Opening and closing are generated for this student at play time, while the course itself stays put.
When the thinking is hers, the AI hands over a card
This is the load-bearing sentence of the whole design. The agent issues a tool call as it would any other — except this time the executor is the student: a thinking card opens in her hands and she fills it in, and what she wrote returns to the conversation to be questioned further. Here the teaching move and the evidence of it are the same object.
Four steps from a decision to a piece of evidence
The seams between the four are narrow enough to be a single function, so the pedagogy can move on its own: change when the AI should stay quiet and you touch the decision layer; add a new card and you write one card's configuration.
Decide
Whether the thinking should go back to her this turn, and which card to send. The whole restraint ladder lives server-side, out of the client's reach.
Hand over
One function connects the decision to the card: summon_card(card, reason, nudge). The trigger is automatic; opening it is her call.
Execute
The card opens in her hands and she fills it in. The AI completes not one field: the executor of this step is a person.
Feed back
What she wrote returns to the conversation to be questioned further, grows the process tree, and becomes the floor the assessment stands on.
The act of offering a card is itself a teaching signal
The system offers a card in the right situation: logged as prompted. She summons it with nobody asking: logged as self-initiated. Same card — and that one difference is the main thing we read when asking whether the method has become hers.
One agent for the whole journey, with an unbroken memory
Framing, planning, reading, writing and review are surfaces of the same Imprint. Changing rooms moves the camera and carries the whole memory along — so in week three it still knows why she dropped that lead in week one. Sub-agents appear only when they're needed.
Reading sub-agent · brief in, takeaways out
In: the project scope and why this source. Isolated on: the full text. Out: five fields — findings, credibility, key quotes, new leads, impact on the proposal. The article body never enters the main thread, so twenty sources later the conversation is still clean.
Assessment sub-agent · best model, never downgraded
The coach can run mid-tier; it only ever asks one question at a time. The assessment can't: it swallows the whole process and returns the two-axis reading plus prose that students, parents and teachers will read again and again. It's the one place we don't economise.
A project runs for weeks: the conversation can neither forget nor grow forever
The answer is to let settled things become structure: a proposal finalised, a source read, a card completed — once stable they're written into the project spine and the raw turns step out of the conversation. Each turn assembles a compact view, and detail is fetched when it's actually needed.
The same help becomes ghost-writing one stage later
“Let me look at that paragraph” is help while she's still deciding on a question and ghost-writing once she's drafting. So the boundary is defined stage by stage: what the AI may do and what it may not are two separate lists at every point.
| Stage | What the AI does here | What it never does |
|---|---|---|
| Framing | Questions a vague interest back into an answerable one, generates search terms, flags an over-broad scope | Never picks the question |
| Sources & reading | Reads long texts in isolation and returns only takeaways; offers SIFT or CRAAP at the right moment | Never decides whether a source can be used |
| Writing | Points at a broken warrant, plays the opposition, checks whether a citation supports the sentence | Never writes a word of the prose |
| Revising | Reads the draft and comments, asking whether a change moved the argument or only the wording | Never makes the edit for her |
| Review | Reads the whole process into a report and names a next step | Never writes her reflection |
A card has worked when it stops being summoned
Usage on its own says nothing. We watch two curves moving together: this card's summons trending down, while the question it packaged starts turning up in the student's own prompts and in her reasons for a revision.
Where she is depends on what she has finished
Stages don't advance on a date, and she doesn't tick a box. A proposal finalised, enough sources read, a first draft in place — real events move the stage forward, and the AI's boundary moves with it.
Facts are computed. Every judgment must cite evidence.
The report has two halves. Everything countable — turns, materials, words, comments, revisions, the timeline — computes straight from the record without calling a model at all. The half that takes judgment goes to the best model available, but it may only cite from a pre-built set of evidence, and any judgment that doesn't resolve is dropped whole after generation.
Every judgment opens
What the model may cite is bounded by an index: a conversation, an event, a card, a source. What a teacher opens is the thing that actually happened at the time.
The two axes stay apart
Cognitive depth and intellectual autonomy are measured and written separately, never merged into one score. For the same concession paragraph, one axis asks how well it was done and the other asks who started it.
Thin evidence gets said out loud
If a dimension has no evidence this cycle the report says so, rather than reaching for a safe sentence to fill the gap. Nothing seen means evidence is still accumulating.
There's a well-worn path to making an AI smarter. There isn't one for making it hold back.
None of the four below gets solved by a stronger model. Each has to be thought through as teaching first and then built — which is where we think the real barrier to entry sits.
One more thing schools ask about that isn't an algorithm: a student's conversation is handled server-side only, the browser never talks to a model directly, and no key ever reaches the front end.
Holding back is harder than being smart
A model's default is to complete the answer. To make it stop at the right moment, handing the thinking back has to become something it can actually invoke — a card a student will fill in and be better for. Without the card, restraint is just a line of prompt nobody obeys.
Support has to change by stage — and then withdraw
The same move flips from help to ghost-writing when the stage changes, so each stage's boundary is defined separately. The harder half is withdrawal: scaffolding is meant to come down, so the metric we watch is a card being summoned less and less while the question it packaged starts appearing in the student's own prompts.
A comment has to be checkable
“His argument has improved” is something no parent or teacher can check. So every judgment carries a real fragment: click and there's the conversation, the card, the source. A judgment that can't point at evidence goes unsaid — which is why a report will sometimes read “not enough evidence this cycle”.
The five feed each other
When a card should be offered is decided from process records left by real projects; how the rubric reads a level comes from seven international mark schemes and three decades of empirical work; and what the report reads is the trail those same cards leave. Any one piece is copyable. Having all of them hold at once — and improve together — is the hard part.
No diagram beats walking it yourself.
The demo runs exactly the five above: how a course waits for her, when a card gets handed over, when a sub-agent takes the load, and how the report ends up tethered to evidence.