AI research2026

EduVision

An adaptive intelligent tutoring system with a neuro-symbolic architecture.

Engines: 5 + RL agent
LLM: Llama 3.1 8B
Learner model: BKT + SRS
Policy: PPO

01Overview

EduVision simulates one-on-one human tutoring. It models what each student knows, decides what to teach next, explains it in natural language and grades the answer - then updates its model of the student and repeats.

Instead of wrapping a language model, the system separates decisions from language: probabilistic and learned components decide what happens pedagogically, and the LLM only turns that decision into dialogue.

02The problem

LLM chatbots answer questions, but they do not teach: they have no persistent model of the learner, no notion of difficulty, and they may state things that are not in the course material.

A tutor needs memory (what does this student know?), strategy (what should come next?) and grounding (is the explanation correct for this course?).

03Architecture

Five decoupled engines communicate through the Pedagogy Engine, which acts as the decision centre. A reinforcement-learning agent tunes difficulty, while platform services handle experiments, explainability and cost.

Clients

Student

Adaptive chat & submissions

Teacher

Lessons, PDFs & rubrics

API consumers

Swagger / OpenAPI

API

FastAPI

Courses, sessions, chat, learner state

Auth

JWT · bcrypt

Engines

Tutor

Dialogue & persona

Pedagogy

Strategy + PPO agent

Learner

BKT mastery & SRS

Assessment

Rubric & code grading

Knowledge

RAG + concept graph

Platform

Plugins

Domain-specific content

Experiments

A/B tests · bandit optimizer

Explainability

Why was this chosen?

Runtime

Cost control · rate limits · metrics

Models & data

Llama 3.1 8B

via Together AI

MiniLM-L6-v2

Sentence embeddings

PostgreSQL

pgvector · async SQLAlchemy

PPO policy

stable-baselines3

04Components

Knowledge Engine

Long-term memory of the course

Ingests PDFs and text, chunks them into ~512-token units and embeds each chunk.
Stores vectors in PostgreSQL with pgvector and relations between concepts in a NetworkX graph.
Serves top-k context to the tutor so explanations stay grounded in course material.

pypdf · sentence-transformers · pgvector · NetworkX

Learner Engine

Probabilistic model of the student

Tracks a mastery probability per skill with Bayesian Knowledge Tracing.
Schedules reviews with spaced repetition before a skill is forgotten.
Classifies errors with an error taxonomy to select remediation.

BKT · SRS · PostgreSQL

Pedagogy Engine

Decides what and how to teach

Combines learner state and retrieved context into an instructional strategy (Socratic questioning, scaffolding, Feynman).
Delegates difficulty to a PPO agent that observes mastery, accuracy, latency, fatigue and current difficulty.

Gymnasium · stable-baselines3

Tutor Engine

Turns strategy into dialogue

Generates explanations, hints and questions with Llama 3.1 8B Instruct Turbo.
Prompted as an educational guide, constrained by the Pedagogy Engine's chosen strategy.
LLM access goes through a provider interface, so the model vendor can be swapped.

Together AI · provider abstraction

Assessment Engine

Grades and gives feedback

AST analysis for code, semantic similarity for text, and LLM grading against teacher rubrics.
Feeds correctness back into the Learner Engine, closing the loop.

05How it works

1
Ingest
A teacher uploads material; the Knowledge Engine chunks, embeds and links it.
2
Start session
The Learner Engine loads the student's mastery profile; the Pedagogy Engine picks a first topic.
3
Teach
The Tutor Engine presents the topic in the chosen style, grounded by retrieved chunks.
4
Assess
The student answers; the Assessment Engine grades it and returns feedback.
5
Adapt
BKT updates mastery; the PPO agent raises, keeps or lowers difficulty; the loop repeats.

06Technical deep dives

Bayesian Knowledge Tracing

Mastery is a hidden variable. Each answer is evidence, weighted by the probability of guessing correctly without knowing (G) and slipping despite knowing (S). After the posterior is computed, the model accounts for learning during the attempt (T).

P (L_{t} ∣ correct) = \frac{P ( L _{t} ) ( 1 - S )}{P ( L _{t} ) ( 1 - S ) + ( 1 - P ( L _{t} )) G} P (L_{t + 1}) = P (L_{t} ∣ obs) + (1 - P (L_{t} ∣ obs)) T

src/core/adaptive/bkt.pypython

if is_correct:
    numerator = L_prev * (1 - skill.p_slip)
    denominator = numerator + (1 - L_prev) * skill.p_guess
else:
    numerator = L_prev * skill.p_slip
    denominator = numerator + (1 - L_prev) * (1 - skill.p_guess)

L_given_evidence = numerator / (denominator + 1e-10)
L_new = L_given_evidence + (1 - L_given_evidence) * skill.p_learn
skill.p_mastery = min(0.99, max(0.01, L_new))

Difficulty as a reinforcement-learning problem

The agent observes a 5-dimensional state - mastery, last-answer accuracy, normalised latency, a fatigue index and current difficulty - and chooses one of three actions: decrease, keep or increase difficulty.

The reward trades off learning gain, staying in the flow zone and session fatigue. A small discrete action space keeps the policy stable and easy to explain.

R_{t} = α (m_{t + 1} - m_{t}) + β 1 [flow_{t}] - γ fatigue_{t}

Grounded answers with retrieval

Each question is embedded and compared to course chunks by cosine similarity. The top-k chunks are injected into the tutor's system prompt as context, so the model explains the course - not the internet.

sim (a, b) = \frac{a \cdot b}{∥ a ∥ ∥ b ∥}

07Design decisions

Neuro-symbolic instead of an LLM wrapper

Pedagogical decisions are made by interpretable models and the LLM only generates language. Every decision can be traced and explained.

BKT over deep knowledge tracing

Four interpretable parameters per skill, cheap per-answer updates and reasonable behaviour with very little data per student.

pgvector inside PostgreSQL

Vectors, learner state and course data live in one transactional store - no separate vector database to operate.

Evaluation built in

A/B experiment and bandit modules compare the RL policy with a static difficulty progression on learning gain, engagement and dropout.

08Tech stack

AI: Llama 3.1 8B (Together AI)sentence-transformersstable-baselines3 (PPO)Gymnasiumfaster-whisper
Backend: Python 3.11FastAPISQLAlchemy (async)PydanticJWT auth
Data: PostgreSQLpgvectorNetworkX
Ops & docs: Docker ComposeGitHub ActionsDocusaurus (EN / AZ)

09What's next

Voice and image input (Whisper, vision) for multimodal tutoring.
Teacher analytics dashboard with real-time mastery maps.
Optimising the policy for long-term retention rather than per-session reward.

Next case study

LangVis

A real-time voice language tutor that corrects every sentence and takes learners from A2 to B2.