VisionaryTutor
An AI-powered, multi-agent learning companion that transforms one-size-fits-all education into an adaptive, explainable, and measurable learning journey.
Inspiration
Traditional online learning platforms usually provide the same content, exercises, and learning sequence to students with very different backgrounds, goals, cognitive preferences, and learning paces.
When learners struggle, these systems may explain the correct answer, but they rarely understand why the learner is struggling or adapt the next learning activity accordingly.
VisionaryTutor started with a simple question:
What if every learner could have an AI tutor that truly understands them?
We wanted to build more than a chatbot that answers questions. Our goal was to create an intelligent learning system that can:
- Understand each learner
- Identify knowledge gaps
- Plan a personalized learning journey
- Generate suitable learning resources
- Evaluate learning outcomes
- Continuously refine its teaching strategy after every interaction
Using computer vision and deep learning as our demonstration domain, we connected conversational learner profiling, retrieval-augmented generation, multi-agent collaboration, personalized resource generation, learning-path planning, and outcome assessment into one continuous learning loop.
What It Does
VisionaryTutor is a personalized multi-agent learning system designed for higher education.
Dynamic Learner Profiling
VisionaryTutor builds a dynamic learner profile through natural-language conversations. The profile may include:
- Academic background
- Prior knowledge
- Learning goals
- Cognitive preferences
- Weak knowledge areas
- Common mistakes
- Learning pace
Retrieval-Augmented Generation
The system uses Retrieval-Augmented Generation, or RAG, to retrieve information from a trusted course knowledge base and attach supporting references to generated content.
This process helps improve factual reliability and reduces the risk of unsupported AI-generated information.
Multi-Agent Collaboration
VisionaryTutor coordinates a collection of specialized agents, including:
- Planner Agent
- Supervisor Agent
- Doc Agent
- MindMap Agent
- Quiz Agent
- Reading Agent
- Path Agent
- Coding Agent
- VideoScript Agent
- Visualization Agent
- Critic Agent
These agents collaborate to complete complex learning tasks and generate different types of educational resources.
Personalized Resource Generation
Based on the learner profile and current learning needs, the system can generate:
- Personalized explanations
- Mind maps
- Quizzes
- Extended readings
- Learning paths
- Coding exercises
- Interactive visualizations
- Video scripts
Adaptive Recommendations
VisionaryTutor recommends the most suitable next resource by considering:
- Learning progress
- Knowledge mastery
- Mastery gaps
- Learning preferences
- Resource usage behavior
The system’s personalization objective can be represented as:
[ r^*=\arg\max_{r\in R} \left( \alpha S_{\text{knowledge}} +\beta S_{\text{mastery-gap}} +\gamma S_{\text{preference}} +\delta S_{\text{progress}} \right) ]
Here, (r^*) represents the most suitable resource for the current learner.
Instead of relying only on keyword similarity, the system considers knowledge relevance, mastery gaps, learning preferences, and current progress.
Learning Outcome Assessment
The system evaluates learning outcomes through:
- Pre-tests
- Practice exercises
- Post-tests
- Learning activity records
- Resource usage records
- Personalized learning reports
Assessment results are used to update the learner profile and improve future recommendations.
Interactive CNN Laboratory
VisionaryTutor provides an interactive CNN laboratory where learners can modify parameters such as:
- Padding
- Stride
- Input matrix values
- Convolution kernel values
Learners can observe the sliding-window process and output matrix step by step, turning an abstract convolution operation into a visible and interactive learning experience.
Isolated Code Execution
The platform allows learners to edit and execute code in an isolated environment.
This helps students move beyond passive reading and verify concepts through hands-on experimentation.
Traceable AI Generation
VisionaryTutor records the information involved in each generation task, including:
- Participating agents
- Model providers and model versions
- Prompt versions
- Supporting references
- Execution time
- Fallback reasons
- Processing status
This makes the AI workflow more transparent, traceable, and auditable.
How We Built It
VisionaryTutor uses a layered architecture with a separate frontend, backend, and AI engine.
Frontend
The frontend is built with:
- Vue 3
- Vite
- Pinia
- Element Plus
Additional technologies support different learning experiences:
- Mermaid for mind maps and diagrams
- KaTeX for mathematical expressions
- MediaPipe for visual and multimodal interaction
- Pyodide for browser-based Python coding activities
Backend
The backend uses Java 17 and Spring Boot 3 to manage:
- User authentication
- Learner profiles
- Learning resources
- Personalized recommendations
- Assessments
- Learning records
- Multi-agent task orchestration
LangChain4j connects the application to language models and retrieval services.
The orchestration workflow follows this general structure:
- A Planner decomposes the learner’s request.
- A Supervisor coordinates task execution.
- Specialized agents generate the required learning resources.
- A Critic reviews the results for factual accuracy, educational quality, and safety.
AI Engine
The Python AI engine handles:
- Document cleaning
- Document chunking
- Embedding generation
- Knowledge indexing
- RAG evaluation
- Learning-resource export
Data and Infrastructure
The system uses:
- Chroma for vector retrieval
- MySQL for core application data
- Redis for caching and runtime state management
VisionaryTutor can also integrate configurable AI models and services, including:
- DeepSeek
- Qwen-VL
- iFlytek
- CogVideoX
Complete Learning Loop
The complete learning loop is:
Learner interaction
↓
Dynamic learner profile
↓
Task planning and knowledge retrieval
↓
Multi-agent resource generation
↓
Factual and educational review
↓
Learning and practice
↓
Outcome assessment
↓
Learner profile update
To keep the system reliable in real-world environments, we implemented:
- Reference validation
- Content-safety checks
- Task timeouts
- Failure retries
- Generation audits
- Graceful degradation
For example, if the vector database becomes temporarily unavailable, the system can fall back to BM25 or term-based retrieval instead of interrupting the entire learning experience.
Challenges We Ran Into
Controlling Hallucinations
Our first major challenge was controlling hallucinations.
Educational content must be accurate, trustworthy, and explainable, especially when it includes:
- Equations
- Algorithmic steps
- Technical definitions
- Executable code
To address this challenge, we created multiple safeguards, including:
- Knowledge-base retrieval
- Reference binding
- Factual validation
- Critic-agent review
Coordinating Multiple Agents
Adding more agents does not automatically produce better results.
We had to determine:
- How tasks should be decomposed
- Which agent should handle each task
- How context should be shared
- How failures should be recovered
- How duplicated work should be avoided
- How uncontrolled loops should be prevented
Clear agent responsibilities, context boundaries, and termination conditions were essential to making the system reliable.
Maintaining Resource Consistency
The same concept may appear in different formats, such as:
- An explanation
- A quiz
- A mind map
- A coding activity
- A visualization
- A video script
These resources must remain aligned in:
- Knowledge scope
- Terminology
- Difficulty
- Learning objectives
Maintaining this consistency across independently generated resources was a significant challenge.
Handling External Service Failures
External AI services, model APIs, vector databases, and video-generation services may become slow or unavailable.
We added:
- Caching
- Retries
- Timeout controls
- Fallback models
- Explainable degradation strategies
These mechanisms allow the core learning flow to continue even when optional services are temporarily unavailable.
Balancing Personalization and Privacy
We also needed to balance:
- Personalization and privacy
- Automation and teacher control
- AI-generated recommendations and human review
We addressed this through:
- Data minimization
- Generation audits
- Transparent system states
- Human-review entry points
Accomplishments We Are Proud Of
Our proudest accomplishment is turning several isolated AI capabilities into one complete learning loop.
VisionaryTutor does more than generate an answer. It can:
- Understand the learner
- Identify knowledge gaps
- Plan a learning task
- Retrieve trusted knowledge
- Generate personalized resources
- Support learning and practice
- Evaluate outcomes
- Update the learner profile
We are also proud that we:
- Built an extensible architecture with multiple specialist agents.
- Supported explanations, mind maps, quizzes, coding activities, visualizations, and video scripts within one platform.
- Developed a citation-grounded RAG workflow with evaluation, auditing, and fallback mechanisms.
- Turned the abstract CNN convolution process into an interactive, parameter-driven experiment.
- Made resource generation traceable through agent status, model versions, prompt versions, execution time, and fallback records.
- Established testing across the backend, frontend, end-to-end workflows, and RAG quality.
- Extended personalization from one-time recommendations into a continuously updated learning-feedback loop.
What We Learned
We learned that the quality of an educational agent depends on much more than the capabilities of the underlying language model.
A reliable educational AI system also requires:
- Trustworthy knowledge
- Clear task boundaries
- Reliable orchestration
- Measurable feedback
- Transparent failure handling
- Continuous evaluation
We also learned the following lessons.
Multi-Agent Systems Need Clear Boundaries
The value of a multi-agent system comes from clear responsibilities, context boundaries, and termination conditions—not simply from the number of agents.
RAG Is More Than a Vector Database
A complete RAG system requires:
- Document cleaning
- Document chunking
- Content licensing
- Citation management
- Retrieval evaluation
- Index lifecycle management
Learner Profiles Must Evolve
A learner profile should not be a static label.
It should evolve continuously based on:
- Assessment performance
- Learning behavior
- Resource usage
- Common mistakes
- Changes in learning goals
Educational Quality Requires Multiple Evaluation Dimensions
Educational content should not be evaluated only by whether an answer is technically correct.
It should also be assessed for:
- Factual accuracy
- Difficulty alignment
- Teaching value
- Clarity
- Actionability
- Safety
Transparent Degradation Builds Trust
Clearly communicating a fallback state is more trustworthy than failing silently when an AI service becomes unavailable.
AI Should Support Thinking, Not Replace It
A good AI tutor should strengthen the learner’s understanding and practical abilities rather than replace the learner’s thinking.
What’s Next for VisionaryTutor
Our next steps include:
- Expanding the knowledge base beyond computer vision and deep learning to support more university courses.
- Introducing knowledge graphs and more advanced knowledge-tracing models for better gap detection and learning-path planning.
- Building a teacher workspace for resource review, agent-policy adjustment, and class-level learning analytics.
- Improving RAG and multi-agent evaluation by measuring citation accuracy, instructional consistency, and real learning gains.
- Supporting more accessible and multimodal interactions, including voice explanations, visual controls, and mobile learning.
- Exploring collaboration between local and cloud models to balance privacy, cost, latency, and generation quality.
- Evolving from a system that generates resources for learners into one that helps them build lasting learning skills.
Long-Term Vision
Our long-term vision is to give every learner an intelligent tutor that understands them, earns their trust, and grows alongside them.
Log in or sign up for Devpost to join the conversation.