LabOps: An Offline Adaptive STEM Tutor
Inspiration
Students do not all learn at the same pace, use the same textbooks, speak the same language, or have reliable access to the internet.
This creates a problem for STEM education. A student may understand part of a Mathematics, Physics, or Chemistry concept but become stuck because the available explanation is too advanced, too simple, disconnected from their syllabus, or dependent on an internet connection.
Cloud AI tutors can help, but they introduce other limitations. They require connectivity, may depend on paid APIs, can lose learner context, and can produce scientifically incorrect answers with convincing language.
We built LabOps to explore a different approach:
Can a capable STEM tutor run locally, adapt to each student, learn how they understand a subject, use their own learning material, and remain scientifically grounded?
LabOps is our answer.
It is an offline-first adaptive Mathematics, Physics, and Chemistry tutor designed to work from Foundation level through undergraduate study.
What it does
LabOps creates a persistent learning environment for each student.
A learner enters a Student ID and begins interacting with the tutor. LabOps can remember information that is useful for future learning, including:
- preferred name
- subject proficiency
- concept mastery
- previous difficulties
- preferred language
- active syllabus
- uploaded textbook
- recent learning context
Each student's data is isolated from every other learner.
Instead of giving every student the same answer, LabOps estimates the learner's current level separately for each subject:
- Foundation
- Secondary
- Advanced Secondary
- Undergraduate
It then adjusts the depth of its explanations, examples, questions, and mathematical treatment.
If a student says, "I don't understand," LabOps does not simply repeat the same response. It can simplify the explanation, change the example, break the concept into smaller steps, or test the prerequisite idea that may be causing the difficulty.
If the student starts answering correctly, LabOps can gradually increase the difficulty.
The goal is to behave more like a tutor following a learner's progress than a chatbot responding to isolated prompts.
Learning from the student's own material
Students often need help with the material they are actually being assessed on.
LabOps therefore allows a learner to use their own:
- syllabus
- textbook
- notes and supported learning material
These resources are indexed locally.
When a student asks a textbook-specific question, LabOps retrieves the relevant local material before constructing its explanation.
The system distinguishes between different information sources instead of treating everything as equally authoritative.
For example, it can separate:
- deterministic scientific calculations
- verified LabOps scientific knowledge
- reference knowledge
- the student's textbook
- the student's syllabus
- generated explanation
This becomes useful when the learner asks questions such as:
"According to my textbook, why does this happen?"
or:
"What should I revise next based on my syllabus?"
LabOps can combine the syllabus, the learner's mastery history, and available learning material to provide a more relevant answer.
Uploaded material is isolated by Student ID, preventing one learner's private textbook context from becoming another learner's context.
Scientific correctness
One of the largest challenges when using language models for STEM education is that a fluent answer is not necessarily a correct answer.
We therefore do not rely entirely on the language model for scientific truth.
LabOps combines local AI with deterministic scientific components for areas where correctness can be checked directly.
These include mechanisms for:
- mathematical calculations
- physical relationships
- unit handling
- chemistry calculations
- chemical equation balancing
- scientific proposition validation
- formula formatting
- misconception detection
For example, if a learner gives a plausible but incorrect scientific statement, LabOps is designed to identify the misconception rather than simply agree with it.
The same principle applies after an AI-generated answer is produced. Critical scientific propositions can be checked before the final response reaches the learner.
This allows the language model to focus on what it is good at, such as explanation and interaction, while deterministic software handles tasks that should be reproducible.
Mathematics, Physics and Chemistry
LabOps currently concentrates on three core STEM areas:
Mathematics
The tutor supports learning across topics ranging from foundational arithmetic and algebra to undergraduate concepts such as calculus, differential equations, vectors, matrices, gradients and related engineering mathematics.
Mathematical notation is rendered locally so expressions such as
[ \frac{\partial f}{\partial x}, \quad \nabla f, \quad \int f(x)\,dx ]
remain readable instead of becoming plain-text approximations.
Physics
LabOps can teach concepts at different depths depending on the learner.
A Foundation student asking about force may receive an intuitive explanation based on
[ F = ma ]
while an undergraduate student can request a deeper mathematical treatment.
The tutor covers areas including mechanics, electricity, circuits, thermodynamics, fields, waves and other Physics topics contained within its verified knowledge base.
Chemistry
LabOps supports Chemistry explanations, calculations, notation and deterministic equation balancing.
Chemical expressions such as
[ H_2SO_4,\quad SO_4^{2-},\quad Fe^{3+} ]
are preserved and displayed correctly.
For suitable equations, structured deterministic processing is used instead of asking the language model to guess coefficients.
Multilingual learning
A major objective of LabOps is to make technical education easier to access in environments where English may not always be the most effective language for learning.
LabOps supports interaction in:
- English
- Shona
- Zimbabwean Ndebele
Students can combine local language with English scientific terminology, as frequently happens in real classrooms.
Equations, symbols, quantities, and scientific relationships remain unchanged when the explanation language changes.
The language resources are also kept separate from scientific evidence. Language data helps LabOps communicate. It does not redefine the underlying science.
Offline by design
LabOps does not require a cloud language-model API for normal operation.
The tutor runs a local GGUF language model through llama.cpp, while retrieval, learner profiles, scientific tools and databases also remain on the device.
The current system uses a compact local model configuration selected for CPU deployment on resource-constrained computers.
This architecture provides several benefits:
- no mandatory internet connection
- no per-question API charge
- learner information remains local
- predictable deployment
- operation in laboratories, schools and homes with limited connectivity
- reduced dependence on external AI services
LabOps is designed around the hardware that students and institutions may already have rather than assuming continuous access to cloud computing.
How we built it
LabOps developed through several architectural iterations.
The original project explored autonomous laboratory experimentation. During development, we identified a broader problem that the underlying technology could address more effectively: personalized STEM learning.
We therefore redesigned LabOps around the tutor.
The system now combines several local components:
- local GGUF language-model inference
- persistent learner profiles
- subject-specific adaptive mastery
- syllabus-aware tutoring
- private textbook retrieval
- local scientific knowledge databases
- deterministic science tools
- multilingual language resources
- response validation
- secure Student-ID separation
- local web interface
- automated regression and release testing
The local knowledge system contains thousands of indexed scientific passages and supports combined lexical and local vector-style retrieval.
The interface and inference pipeline are designed to keep prompts compact so the tutor remains usable on limited hardware.
Challenges we faced
Making a small local model useful
A compact model cannot be expected to memorize every detail of Mathematics, Physics, and Chemistry while also reasoning perfectly.
Instead of solving this by continuously increasing model size, we reduced how much the model itself must do.
Retrieval provides relevant knowledge.
Learner state provides the required educational level.
Deterministic systems perform calculations and validation.
The model focuses on interpreting the learner and constructing the explanation.
This made a relatively small local model significantly more useful.
Preventing confident scientific errors
Scientific hallucinations were one of the most difficult problems.
Keyword checks were insufficient because an answer could contain all the expected scientific terms while expressing an incorrect relationship.
We therefore introduced proposition-level validation and tests containing deliberately plausible misconceptions.
Maintaining learner privacy
Persistent learning only works if LabOps remembers the correct student.
We built strict Student-ID separation and tested conflicting learner profiles, simultaneous users, textbooks, syllabi, languages and stored progress.
Resetting a conversation, resetting mastery, removing a textbook, clearing a syllabus and completely forgetting a learner are treated as separate operations.
Handling textbooks safely
Retrieved documents are evidence, not instructions.
A textbook can contain malformed content or even text that resembles an AI instruction.
LabOps treats retrieved material as untrusted source content and does not allow embedded instructions to override the tutor.
Running within limited resources
Local inference introduces memory and latency constraints.
We reduced prompt context, bounded caches, made textbook and language resources lazy-loaded where possible, reused model prompt prefixes and optimized retrieval so that LabOps can operate within competition hardware limits.
What we learned
Our largest lesson was that a good educational AI system is more than a language model.
The useful part of LabOps comes from the system surrounding the model.
A tutor needs to know:
- who the learner is
- what they already understand
- what they are studying
- what they got wrong previously
- which explanation style is appropriate
- which source should be trusted
- when a calculation can be verified
- when the system should admit that available evidence is insufficient
We also learned that smaller local AI models become more capable when their responsibility is clearly constrained.
Instead of asking one model to remember every fact, perform every calculation, maintain every student profile and judge its own correctness, LabOps delegates those responsibilities to specialized components.
Testing covers areas including:
- scientific correctness
- adaptive learner behavior
- learner isolation
- textbook isolation
- syllabus isolation
- memory and reset behavior
- multilingual tutoring
- scientific-symbol rendering
- adversarial student prompts
- misconception handling
- concurrent learners
- offline operation
- security
- repeated startup and restart behavior
The objective is not simply to show that LabOps can generate an answer. It is to demonstrate that the surrounding tutoring system behaves predictably.
What's next
The next stage of LabOps is to move from a tested software system into real learning environments.
We want to:
- expand the verified Mathematics, Physics and Chemistry curriculum
- conduct structured trials with students
- measure improvement in concept mastery over time
- improve Shona and Ndebele technical-language quality
- add more syllabus systems and educational standards
- strengthen undergraduate engineering content
- improve support for diagrams and visual explanations
- continue reducing inference latency and memory usage
- expand teacher-facing progress tools
- explore optional integration with physical laboratory equipment
Our goal is to make LabOps a tutor that can run where the learner is, understand how that learner is progressing, use the material they are actually studying, and provide scientifically grounded help without depending on continuous internet access.
Log in or sign up for Devpost to join the conversation.