Tutor Progress: First Real Lessons Learned

Tutor has started teaching real lessons, and the honest version is more useful than the polished one.

The prototype works. Not perfectly, but enough that we can see the shape of the product. It remembers prior context. It can retrieve course material. It can notice when a student is looping on the same kind of mistake. It can sometimes explain a concept in a way that makes the room go quiet for a second.

Then, ten minutes later, it can retrieve the wrong thing and remind us that this is still early.

What We Tested

The first lessons were built around the pieces we actually have:

• recent conversation context
• RAG retrieval over course notes and prior sessions
• structured student progress records
• model prompts tuned for teaching rather than answer dumping
• logs we could inspect afterward

No subject LoRAs yet. No hot-swapped calculus adapter. No fine-tuned library of teaching minds.

That is still the direction we want to go, but pretending it already exists would be dishonest. The compute is not available yet, and the models worth adapting are not small enough to make this easy on the hardware we have.

The Basketball Lesson

One of the first useful tests was a physics explanation through basketball.

The student did not care about projectile motion in the abstract. They cared about why a shot arcs the way it does, why release angle matters, and why the ball feels different from different spots on the court.

Tutor did well when the retrieval layer brought in the right lesson material and the recent conversation kept the student's interest in view. It could talk about velocity and gravity without immediately turning into a textbook.

That is the promising part.

The weaker part was consistency. Sometimes the system leaned too hard on the retrieved material. Sometimes it gave a correct explanation that was not the explanation this student needed. Those failures are exactly why we are still prototyping.

What We Learned

Three lessons stand out.

Memory matters. The difference between a one-off answer and a remembered lesson is enormous. When Tutor knows what the student struggled with yesterday, today's explanation can start in the right place.

Retrieval quality matters more than fancy claims. A better chunk, summary, or course note can improve a session more than any marketing phrase about personalization.

Specialization is still the next frontier. RAG can provide context, but it does not fully change the model's teaching instincts. That is why Nathan keeps coming back to LoRAs as a future layer: not to store facts, but to shape behavior.

The Hardware Wall

This is where ambition runs into cost.

The long-term Tutor architecture wants a powerful local base model and course-specific fine-tuning. The hardware to do that properly is expensive. The open models we would actually want to use are getting better, but they are also large enough that mid-2026 hardware planning already feels behind the model curve.

So the practical plan is simple: build with what we can afford, make Tutor useful, create revenue, and then justify the next compute spend.

That is not as glamorous as saying the adapters are already live.

It is more accurate.

Live curiously and give generously.