AURA | Devpost

Shows that there is actual improvement for each concept when a question is answered correctly.

Students rarely struggle with the exact same concepts in the exact same way. However, most AI tutoring tools still treat students similarly: a student asks a question, and the AI generates an answer without a persistent understanding of what that individual student already knows.

That inspired us to build AURA, an adaptive AI tutor that learns two things: the professor's course and the individual student.

Our core idea became:

Same professor. Same lecture. Same question. Different student. Different explanation.

Rather than creating another “chat with your PDF” application, we wanted to explore what happens when an AI tutor can adapt its teaching to the learner.

What it does

AURA combines course-specific knowledge with an evolving student mastery model.

Professor-provided lectures, PDFs, and notes can be processed into course knowledge that AURA can retrieve when answering questions. At the same time, AURA maintains information about individual students and their mastery of course concepts.

This allows the tutoring system to consider both:

What should be taught? — determined by the professor's course material. How should it be taught? — influenced by the individual student's current understanding.

Practice and learning interactions can then feed back into the student's mastery state, creating a cycle where the tutor can become more personalized as the student continues learning.

How we built it

AURA was built primarily in Python, with a backend responsible for course ingestion, student state, mastery tracking, retrieval, and tutoring.

We created a RAG-based pipeline to retrieve relevant information from course materials and combine it with student context before generating tutoring responses. We also designed a concept-level mastery system so that a student's knowledge can be represented more precisely than a single overall grade.

For identity, we integrated Auth0 authentication and map authenticated users to internal AURA student records. This allows the backend to determine which student is making a request instead of trusting a student ID supplied by the client.

Together, these components form a feedback loop:

Course Material → Retrieval → Student Context → Personalized Tutoring → Practice → Learning Events → Updated Mastery

Challenges we faced

One of our biggest challenges was integration. AURA has several interconnected systems—authentication, course ingestion, RAG, student mastery, AI generation, the database, and the frontend—and each was being developed in parallel during the hackathon.

We also had to think carefully about the difference between simply remembering a user and actually modeling a learner. Designing the system around concept-level mastery and learning events helped us move toward meaningful personalization rather than relying only on conversation history.

Finally, connecting authentication to personalization introduced an important security challenge. We needed to ensure that a user could not simply provide another student's ID and receive tutoring based on that student's data. We addressed this by deriving the student's internal identity from their authenticated account on the backend.

What we learned

The biggest thing we learned is that building an adaptive tutor is much more than connecting an LLM to course documents. Retrieval gives the AI knowledge of the course, but personalization requires knowledge of the learner.

We also learned how important system architecture becomes when multiple developers are building interconnected components under a tight deadline. Creating clear boundaries between ingestion, retrieval, authentication, student state, and generation allowed us to bring those pieces together into one larger idea.

AURA represents our vision of an AI tutor that doesn't just become better at answering questions—it becomes better at teaching the person asking them.