The problem, stated plainly
A learner cannot tell a correct explanation from a merely fluent one. That inability is what it means to be a beginner.
So when an AI tutor confidently walks through an algorithm and describes something the code does not actually do, it is not a small error. It teaches something false to the one person who has no way to detect it — and they carry that misunderstanding forward into everything built on top of it.
Every AI tutor in production today asks students to trust output that nothing verified. That is the gap Forever closes.
What it does
Give Forever any source material — a textbook chapter, lecture notes, a problem statement — and it generates a complete multi-scene course: a board drawn as a tutor voice explains it, real code executed in a sandbox, a step-by-step visual walkthrough, and questions that check understanding.
The difference is what it refuses to do. Every visual walkthrough is compiled from a recording of a real execution, never from a model's guess. Every factual claim on the board must cite the source it came from. Teaching that fails those checks is dropped rather than shipped weak.
Not a demo — a running system
This is deployed and operating, not a prototype assembled for a submission:
- Live on Alibaba Cloud ECS, running under Docker Compose
- 21 courses and 149 lessons already generated and stored
- 957 automated tests in continuous use
- 103 algorithms visualised with zero per-problem code, at zero errors
- Background job queue, progressive delivery, honest failure handling
The correctness battery is the number I would point a technical reviewer at. Nothing is hand-tuned for any individual algorithm — the engine records a real execution and derives the visualization from that recording alone. That is what makes it a system rather than a set of demos.
Who it is for
Students learning technical subjects where being confidently misled is expensive: algorithms, databases, machine learning, systems. The courses already generated cover exactly that ground — searching algorithms, dynamic programming, database denormalization, machine learning fundamentals, computer networking, linear algebra.
Secondarily, educators who need lesson material generated from their own source rather than from a model's memory of the internet.
How it works
Eight specialised agents orchestrated as a LangGraph state machine, wrapped in deterministic validators the models cannot argue past:
START → design → audit → ┬→ accept → END ├→ revise → audit (bounded loop) ├→ arbitrate → END └→ fail
A Board Director designs each scene. A Grounding Auditor objects to any claim the source does not support — it is a hard gate. A Pedagogy Critic objects to teaching that will not land. An Arbiter rules on deadlock. A Code Runner executes real code; an Execution Tracer records what actually happened; a Voice Writer narrates and declares which lines carry which teaching move.
The models write the teaching. A real recorded execution decides what is true.
Built on Next.js and Node, Qwen models via Alibaba Model Studio behind a single client, BullMQ and Redis for background course builds, MongoDB for storage, and a network-isolated sandbox for code execution.
What I learned building it
Honest failure is a feature. It is tempting to build a system that always produces something. It is far more useful to build one that refuses when it cannot verify — because in education, a confident wrong answer costs more than no answer.
A system is only as good as the path you actually test. For a long stretch I measured a convenient internal code path while the real production path was failing for reasons my tests structurally could not see. The bug that taught me this was severe: a dead text-to-speech vendor was deleting finished lessons, because voicing ran inside scene generation, so a scene that could not be spoken was discarded even after passing every teaching check. Audio is an enhancement; the teaching is the product. It now ships as text and logs the failure loudly.
Most production failures are not algorithmic. Six configuration and error-handling faults stacked up, and each one individually looked like total product failure — an app pointed at an empty database, a queue worker that was not running, retry logic that did not recognise the two most common network errors. Reliability engineering was harder than the AI.
Known limits, stated honestly
- Verified visual walkthroughs cover recognised algorithm families. Unsupported shapes get an honest generic trace, never a guessed animation.
- The execution recorder is Python-only today; JavaScript gets a basic view until a JS recorder exists.
- Teaching gates are deterministic, so they catch structural failures rather than every semantic one — grounded but circular prose can still pass.
I would rather state these than have a reviewer discover them.
What comes next
- Path-reconstruction visuals for dynamic programming
- A JavaScript execution recorder, extending verified walkthroughs beyond Python
- Mastery-driven practice — the model exists; wiring it to question selection means the tutor picks what you have not learned rather than what comes next in a list
- Educator tooling — bring your own curriculum, get verified lessons from it
Scope
Forever is an ongoing open-source project under AGPL-3.0 and its commit history is public. Work during this event focused on the execution-verification invariants, the teaching-contract validators, and the reliability of the generation pipeline.
Log in or sign up for Devpost to join the conversation.