Space Academy: an AI Tutor Built From a Real School Textbook, One That Teaches Instead of Solving

My son is nine, in second grade, and has ADHD. Evening math homework looks like this: he can calculate, but attention drifts by the fourth exercise, notebook margins fall apart, and every app from the store is finished in one evening with a request for a new one. So we built our own. It is a working web tutor based on his real school textbook (kids.automata.sale), and I am writing this because the combination of decisions inside it appears to be rare worldwide.

Why the store apps did not help

We tried the popular trainers. The shared design: a space or animal skin, stars for correct answers, an input field. A kid with ADHD quickly learns that the game rewards taps, not understanding, and develops a guessing strategy. None of the apps we saw could do three things:

• take exercises from our textbook, with our numbering and wording, so the notebook can be shown to the teacher in the morning;
• first check what the child already knows instead of loading everything;
• give hints without naming the answer.

So Space Academy was born. The student is a cadet in a space school, exercises are missions, progress follows the Apollo 11 route from Earth orbit to the Sea of Serenity, with a collection of 15 rockets for solved series. But space is only the skin. Inside there are four engineering loops, and each deserves its own section.

System map

   TEXTBOOK SCAN            learn METHOD              LLM MENTOR
        |                         |                        |
  multi-pass OCR           probe -> plan -> teach     socratic mode,
  + letter-by-letter       encoded in the data        answer banned
  human verification             |                    by the prompt
        |                         |                        |
        +----------+-------------+----------------+--------+
                   v                              v
            TASK DATASET                  ASK MISSION CONTROL
            (117 cards)                   (explain / hint / example)
                   |                              |
                   +--------------+---------------+
                                  v
                    CARD + SCHOOL NOTEBOOK MODE
                    (solve in the app, write as at school)

At the bottom of that map sits the most important part: the app does not replace school, it prepares for it. Loop by loop.

Loop 1. Content pipeline: scan, OCR, letter-by-letter verification

Homework is assigned from a specific textbook, so the source of truth is the textbook page, not a generative model’s imagination. The pipeline:

page scan (PNG, 300 dpi)
   |  vision model, narrow prompt: "transcribe task N verbatim"
raw text
   |  second pass on disputed fragments
verification: model text against the scan
   |  mismatch? -> the scan wins
TBTask, a card in the app dataset

Two rules. First, full-page transcription by vision models is unstable, while narrow one-task prompts are reliable, so pages are read piece by piece. Second, only wording confirmed by a repeat reading of the scan enters the dataset.

Why so much caution? A real case. An external agent prepared five tasks for page 20, and verification against the scan caught it: in the angle-counting task the agent had picked the wrong figure and “found” a right angle in the hexagon, while on the scan the right angle belongs to the pentagon. Had that shipped, my son would have memorized an error and brought it to class. The pipeline caught the mismatch before publication. In a month and a half this produced 22 pages of two textbooks (math and Russian), 117 exercises, and not a single wording invented “by feel”.

Loop 2. The learn method: probe, plan, teach, encoded in data

The pedagogy comes from the open learn method (the amosblomqvist/learn repository): unconditional truths first, derived steps second; every node is motivated, then established, then linked to the previous one and fixed with a quiz. The core idea: understanding is a connected dependency graph, not a pile of facts.

In the app the method lives in the data schema of every task, not in illustrations. By phase.

Probe, a knowledge map before the lesson. Every task opens with a “detective interrogation” of its condition, and the first questions are deliberately easy checks of the supporting skills. Before the cucumber word problem, “what is 6 + 4?”; before the segment task, “how many millimeters are in a centimeter?” In learn terms this is finding the edge of knowledge: confirm the floor first, then reach for the ceiling. A kid with ADHD gets an early win and enters the task without fear.

Plan, a route for the page. Above the cards sits the “Maneuver Plan”: a small DAG in human language, from the foundation (“part + part = whole, you already have it”) through nodes tied to task numbers to the goal of the maneuver. The child sees why this task, right now, and what comes next. The method requires showing the plan to the student and getting consent, and that is exactly what the plan block does.

Teach, a cycle per node. A task carries four properties: a hook, the motivation for why the skill matters (“inverse problems are a time machine: reconstruct the question from the answer”), the verbatim task text, an explicit link to the previous node (“in task 1 you saw the purchase flip inside out, now flip it yourself”), and a quiz after solving.

A separate word on quizzes. Distractors follow the learn rule: the correct option is written first, wrong ones are mutations of it, same length, same shape, each a real, diagnostic mistake. A child who picks “7 + 4” instead of “7 − 4” gets an explanation, not just a red cross.

Loop 3. Mission Control: an LLM with no right to answer

Every card has mentor buttons: Explain, Hint, Similar example. Behind them is an LLM (GLM via the z.ai API), and its entire design serves one ban: never solve for the student.

• Only the task text goes to the server. The correct answers are never transmitted, so there is nothing to leak.
• The system prompt encodes the method: short, three to five sentences, motivate, end with one question that moves toward the solution. The similar-example mode works through an analogous problem with different numbers, naming that example’s answer but never the original task’s.
• Replies are spoken aloud with speech synthesis, so reading is optional.
• Every question is logged to the database, so in the evening the parent sees exactly where things got stuck.

It is the same principle we run in our CRM with AI executives: the agent prepares the reasoning, the human decides. In the kids’ version it is stricter, because the model literally does not have the answer.

Loop 4. The notebook bridge

The big discovery of first grade: for my son (and half the class) the problem is not arithmetic but formatting. The teacher grades the notebook, not the app. So after every solved task the app shows a model entry on a squared sheet, in the exact orthographic mode of primary school:

• a margin of four cells with a red line;
• the date on the 11th cell, “Homework.” indented five cells;
• “Task 1.” indented, the short record and “Answer:” capitalized, lines spaced one cell apart;
• columns of exercises three cells apart, with automatic wrapping to sheet width;
• a handwriting font in blue “ink”, like a real notebook.

The child solves in the app, where input is easier and feedback is instant, then transfers to paper following the model. One button produces a share link for the teacher: a public page, no login, showing the task, the answers, and “the cadet’s reasoning”.

An interface designed for ADHD

A few decisions that made our specific case work:

• Tasks split into steps: detective interrogation, then input one example at a time (the field sits next to its own example, not “twelve identical cells in a row”), then the notebook. No screen with a dozen identical boxes.
• Patterns with continuation: columns of exercises stand as in the textbook, and “continue the column” asks for both the next number and the answer, so the rule is checked, not just arithmetic.
• Speech: any task and any mentor reply is read aloud.
• Progress as a story: the Apollo 11 route from orbit to splashdown, 15 rockets in the collection, rewards for series, not for taps.
• Short missions with a clear finish.

The tech

Deliberately boring: React 18, TypeScript, Vite and Tailwind on the front end; Express with SQLite (better-sqlite3) on the back end; pm2 and nginx on the server; student accounts with cookie sessions, progress synced across devices. Content is prepared by an agent in the IDE following the pipeline described above, and a human approves publication. The same “agent prepares, human decides” principle as in our grown-up automation.

Why projects like this are rare

For such a system to work, five conditions must hold at once, and that combination is scarce:

1. Subject-matter discipline: a teaching method encoded down to data fields, not gamification painted over a PDF.
2. An agent content pipeline with scan verification, because without it LLM-generated wording quickly hallucinates a textbook.
3. LLM discipline: a mentor designed around a ban on giving answers, with the correct answers isolated from the model.
4. Respect for the school standard: the notebook bridge with orthographic formatting, because homework is delivered on paper.
5. An engineer-parent nearby who watches every evening where the system fails and fixes it.

The edtech market is huge, but it is almost entirely either content platforms without an AI loop or AI solvers that do the homework for the child. The middle, a machine that teaches how to learn from your own textbook, is nearly empty. That is the interesting place.

What is next

The short roadmap: switching the mentor to a live key (the server-side construction is already waiting for it), new textbook pages as the school program moves on, and the main experiment, the same content model for a whole class, where teachers see the progress notebook through public links.

If you are building something like this for your kids or thinking about it, write to me, let’s trade notes.

Phone: +7 (906) 311-77-69, email: hello@automata.sale, Telegram: @automatasale, site: automata.sale

Evgeny Uryadov, sole proprietor (INN 645112058391, OGRNIP 312645301900058). Working across Russia, Belarus and Kazakhstan.