QuackTrack

🌟 Inspiration

This project was born from my thesis research, which explored how artificial intelligence (AI) could help make education more adaptive, human, and culturally responsive.

In a diverse and digital world, students deserve more than standardized learning paths. They need tools that understand who they are, how they learn, and what drives them. I became fascinated with the idea of using AI to guide students not just academically, but metacognitively — helping them reflect, build self-awareness, and grow with purpose.

What inspired me most was the intersection between cognitive psychology and educational technology. Research shows that students who actively reflect on their learning achieve significantly better outcomes. I wanted to create something that supports that — not with rigid assessments, but with warm, personalized guidance that helps students track their growth, understand their challenges, and shape an authentic professional identity over time.

This project represents the first step in building a system that puts reflection, empathy, and adaptability at the center of the learning experience.

🐤 The name QuackTrack comes from a playful blend of “quack” — like the little rubber ducks used in rubber duck debugging — and “track”, as in tracking progress. This AI doesn’t just listen — it interprets, connects, and gives you cues to think more clearly.

🧠 What it does

QuackTrack is a conversational AI system that helps university students reflect more deeply and intentionally on their academic journey. Instead of correcting grammar or offering generic feedback, it engages students in thoughtful dialogue to help them connect their experiences to learning goals, identify strengths and areas for growth, and build a meaningful professional profile over time.

At the core of QuackTrack is a multi-agent architecture that analyzes each student message and routes it to the most suitable agent:

The Socrates Agent asks open-ended questions based on the Socratic method to encourage deeper thinking.
The Feedback Agent delivers warm, natural responses that affirm the student’s perspective and offer constructive guidance.
When requested, the system can generate a summary of the student’s professional profile or progress, built from their history of reflections.

All interactions are filtered by an ethical orchestrator that ensures safety, fairness, and data protection. QuackTrack adapts dynamically to the depth and tone of each student message, offering just the right balance of challenge and support to foster metacognitive growth.

🛠️ How we built it

QuackTrack was built using the Agent Development Kit (ADK) with Python, following a modular, scalable multi-agent architecture. The system is designed to route each student message to the appropriate internal agent, based on message content and cognitive depth.

We integrated Vertex AI and Google Cloud Functions to support natural language understanding, memory, and orchestrated workflows. Here’s how each agent works:

🧠 Orchestrator (step runner): With the help of Gemini and NLP, it interprets the user’s message, activates key logic flags, and ensures that all agents complete their cycles, callbacks, and operate in a coordinated sequence.
👋 Greeting Agent: Welcomes the student and initiates the conversation warmly. It briefly explains how the QuackTrack system works and what the user can expect.
🛂 Customs Agent: Evaluates whether the input complies with ethical and safety standards. If it detects sensitive, discriminatory, or risky content, it halts the flow and triggers the escalate function to pass control to the proper agent.
✅ Requirements Checker: Determines whether the message should be stored in memory. If it relates to learning, it saves the message silently and forwards it to the Argument Builder. If not, it kindly informs the student that the system is focused on educational development.
📁 RAG Tool: Retrieves educational resources from Google Drive. It functions as external memory, bringing in rubrics, activity guidelines, and examples to enrich feedback and reflection.
🧱 Argument Builder: Supports students in expanding short or vague messages. It asks focused questions to build a coherent argument that can then be analyzed by the Socrates Agent.
🧠 Memory Tool: Acts as the system’s active memory. It stores meaningful inputs related to learning so other agents can reference them, ensuring coherence and enabling detection of progress, themes, and insight development.
🔎 Socrates Agent: Encourages metacognitive reflection using the Socratic method. It asks one open-ended question per turn, based on the student’s input and memory history—deepening weak arguments, constructively challenging strong ones, and highlighting valuable insights.
🪞 Reminder Agent: Generates a personalized reflective report summarizing the student’s learning progress, strengths, and how this knowledge might be applied—helping them recognize their growth and potential.

This modular setup allows new agents, tools, or guardrails to be added or swapped without rewriting the system’s core logic.

flow-basic multiagent-flow

🚧 Challenges we ran into

⚖️ Balancing warmth and structure: One of the biggest challenges was designing prompts that felt genuinely human, supportive, and reflective — without losing clarity or pedagogical value. We wanted the AI to feel like a mentor, not a chatbot.
🧭 Ethical routing logic: Routing messages correctly (especially vague or brief ones) required complex decision trees. We had to ensure that every message was analyzed not only for content, but also tone, intent, and potential risks — all without over-interpreting the student’s words.
🧠 Integrating psychology without oversimplifying it: Translating cognitive psychology principles (like metacognitive scaffolding or self-regulation) into prompt instructions and system logic was a delicate process. We didn’t want to reduce deep educational theory into shallow automation.
🧩 Multi-agent orchestration: Managing dependencies between agents while keeping the system modular was technically challenging. We needed agents to communicate meaningfully without creating brittle logic or state confusion — especially between Socratic turns and feedback outputs.

📚 What we learned

Modular AI design pays off: Building with a multi-agent mindset from the beginning allowed us to separate concerns, iterate faster, and debug more easily. Instead of relying on a single LLM prompt, we could assign each agent a focused role — and evolve them independently.
Tone matters as much as output: Students engage more meaningfully when feedback feels human, warm, and sincere. Finding the right tone — not too academic, not too robotic — was just as important as delivering correct or helpful answers.
Metacognition needs friction — but the right kind: Reflection is inherently effortful, and part of our challenge was designing an experience that invites students to think without overwhelming them. We learned that asking one good question at the right time is better than five average ones.
Guardrails are not optional: From bias mitigation to privacy policies, we confirmed that ethical safeguards must be built into every layer of the system — not tacked on later. This is especially true when working with students and sensitive educational data.
The small touches matter: Even something as simple as the name — QuackTrack — helped shape the personality of the project and communicate its core values: listening, guiding, and supporting growth with empathy and clarity.

🧰 Built With

Python 🐍
Agent Development Kit (ADK)
Gemini 2.5 (via Vertex AI)
Google Cloud Functions
Markdown & JSON prompt chaining

🔄 System Flow: Input → Processing → Output

🟡 Input

Student Message Free-form reflections, learning thoughts, or open-ended responses.
Preloaded Context Academic program, prior reflections, and rubric data (if available).
System Prompts Internal triggers from agents (e.g., Socratic questions, scaffolding cues).

⚙️ Processing

Managed by the Sequential Agent (Orchestrator), the system executes the following sub-agents in order:

Greeting Agent – Initiates the session and introduces the system.
Customs Agent – Applies ethical/safety filters and handles escalation.
Requirements Checker – Validates if the message is relevant for processing and memory.
Argument Builder – Expands short or vague inputs via clarifying questions.
Socrates Agent – Generates one Socratic question based on input and memory history.
Reminder Agent – Summarizes the student’s learning evolution and generates a reflective report.

Throughout this flow, the Memory Tool is used to load and store relevant information, enabling context-aware personalization.

🟢 Output

Constructive Feedback Personalized responses grounded in cognitive and emotional understanding.
Socratic Prompt One open-ended question designed to promote reflection.
Reflective Summary A final output highlighting progress, strengths, and possible applications.

🔮 What’s next for QuackTrack

QuackTrack is just the beginning. Moving forward, we aim to:

Deploy it in real classrooms: We’re currently exploring partnerships with universities to pilot QuackTrack in reflective learning activities, especially in portfolio-based or project-based courses.
Build a teacher dashboard: A next step is developing an interface for educators to view aggregated insights, student progress, and reflection depth — while preserving student privacy and autonomy.
Add multimodal inputs: We want students to reflect not only through text, but also voice, sketching, or even mood check-ins — using those inputs to trigger different agent flows.
Train adaptive profiles: By enriching the Memory Tool, we plan to build evolving learner profiles that adapt over time — identifying not only cognitive growth, but also shifts in motivation and interests.
Open source the architecture: Once stabilized, we’d love to share the agent orchestration patterns (built with ADK) so others can create ethical, reflective systems in other fields like health, law, or community work.

As QuackTrack evolves, we hold onto a simple truth: