Hallucination isn't a bug they forgot to fix
A language model predicts plausible continuations of text. That is not a flawed implementation of a truth-telling machine — it is the thing itself, working as designed. Truth is not a variable in the objective. A well-formed false sentence and a well-formed true one look identical to the mechanism producing them, and it will produce either with the same confident cadence.
The models have got dramatically better, and modern ones are right about an enormous amount. But "usually right" is a different property from "tells you when it doesn't know", and no amount of scaling turns the first into the second.
The asymmetry that makes this a student problem
A programmer who gets a hallucinated API method finds out in about four seconds, because the code doesn't run. A lawyer who gets a hallucinated case finds out when the judge looks it up — later, and much worse, but they do find out.
A student who gets a hallucinated fact finds out in the exam. There is no compiler. There is no opposing counsel. The feedback loop is measured in weeks, and it terminates at the only moment that counts. You cannot fact-check a subject you are in the process of learning — that is what it means to be learning it.
What actually helps: grounding
The fix is not a better model. It is to change the question the model is asked. Instead of "what is the answer", which invites it to draw on everything it has ever seen, you retrieve the relevant passages from a trusted source — the student's own material — and ask "what do *these passages* say". This is retrieval-augmented generation, and its value is not really the retrieval. It is that it creates something to point at.
Because now the answer can carry a citation, and a citation is falsifiable. Click it. Read the page. If the page doesn't say what the answer claims, you have caught the model in about five seconds — the compiler the student never had.
But RAG alone isn't enough
Here is the failure mode that most "grounded" tools still have. Retrieval returns the top few passages *whether or not any of them are relevant*. Ask about something your material doesn't cover, and the model receives three irrelevant passages and a question — and it will still answer, blending the irrelevant context with its own prior knowledge, in the same confident voice, sometimes with a citation attached that does not support the claim. A citation that nobody checks is decoration.
So grounding has to be enforced, not merely attempted. In Thaxas that means three independent layers:
- A similarity floor. If nothing retrieved clears a cosine-similarity threshold, generation does not happen. The model is never called, so there is nothing to hallucinate.
- A required refusal. The system prompt mandates an explicit sentinel when the retrieved passages don't answer the question — not a graceful hedge that reads like an answer.
- A visible badge. When an answer ran outside your material, the interface says so. You are never left guessing which mode you were in.
Any one of those can be defeated. Three at once is a much harder thing to slip past — and, crucially, the failure is *visible* rather than silent. That is the whole design goal: not a tool that is never wrong, but a tool whose wrongness you can see.
How to test any AI study tool in two minutes
Upload one lecture. Ask it something from a completely different week — a topic you are certain the file does not cover. Then read what comes back very carefully. Did it tell you the material doesn't cover this? Or did it produce a fluent, plausible, sourceless answer?
If it did the second thing, you have learned something important: for every future answer, you have no way to tell which mode it was in. Run this test on us too. We would rather you did.