# How We Built an AI That Remembers Your Team's Failures — Before They Happen Again > Source: > Published: 2026-07-01 16:09:00+00:00 Built at HackHazards '26 · FlowMind Every semester, student teams repeat the same mistakes. Wrong person assigned to the wrong task. Decisions made in week one forgotten by week three. One person carrying 80% of the work while nobody notices until submission day. We tried Trello. We tried Notion. We tried Jira. They all had the same fundamental flaw — they record what happened. None of them learn from it. So we built FlowMind. FlowMind is an AI-powered group project manager built on persistent memory. The one-line definition we kept coming back to: "FlowMind is an AI project manager that learns your team and predicts failures before they happen." Every other tool starts fresh every project. FlowMind's memory compounds. The longer your team uses it, the smarter it gets. | Layer | Technology | |---|---| | Frontend | React 18 + Vite | | Backend | Node.js + Express | | AI / LLM | Groq API (llama3-70b-8192) | | Persistent Memory | Hindsight by Vectorize | | Knowledge Graph | Neo4j | | Voice Transcription | Web Speech API | | Deployment | Vercel + Render | Hindsight gives AI agents three core primitives: `retain()` , `recall()` , and `reflect()` . Every intelligent feature in FlowMind maps to one of these. retain() — Every task completion, decision, and meeting gets stored: ``` await hindsight.retain({ key: `task_${task.id}`, value: { assignedTo: task.assignedTo, estimatedHours: task.estimatedHours, actualHours: task.actualHours, completedOnTime: task.completedOnTime, taskType: task.taskType, }, tags: ['task', 'performance', task.assignedTo] }) ``` reflect() — Generating pre-failure warnings from memory patterns: ``` js const warning = await hindsight.reflect({ query: `Flag delay risks based on this team's past patterns`, memoryBank: `team_${team.id}`, includeObservations: true }) // Returns: "72% delay risk — backend tasks took 2x estimate in past cycles" ``` The most powerful part was Observation Consolidation — Hindsight automatically synthesizes raw retained facts into behavioral insights. We planned to write 200 lines of custom pattern-detection logic. We found auto-consolidation and deleted all of it. The system learned our team's patterns on its own. We used Neo4j to model team relationships as a graph. Members, skills, tasks, and outcomes all exist as nodes connected by edges. ``` // Create member-skill relationships MATCH (m:Member {name: "Piyush"}) MATCH (s:Skill {name: "React"}) CREATE (m)-[:HAS_SKILL {level: "advanced"}]->(s) // Find best person for a frontend task MATCH (m:Member)-[:HAS_SKILL]->(s:Skill) WHERE s.name IN ["React", "CSS", "JavaScript"] AND (m)-[:COMPLETED]->(:Task {type: "frontend", onTime: true}) RETURN m.name, count(*) as score ORDER BY score DESC ``` This is what makes FlowMind's task assignment genuinely intelligent. When the AI assigns a task to someone, it's not guessing — it's traversing a graph of real team relationships and past performance data. Before Neo4j, assignment reasons were generic. After Neo4j: "Assigned to Piyush — 6 frontend tasks completed, 90% on-time rate, React and Vite in skill graph." That's the difference between a chatbot and an actual AI project manager. We used Groq's llama3-70b-8192 for three things: Meeting Analysis — After a voice meeting ends, the full transcript + member skill profiles + Neo4j team graph gets sent to Groq. It returns structured JSON with extracted tasks, assignments with reasoning, decisions, and follow-up items. Response time: under 3 seconds. AI Chat — Full conversational access to team memory. Leader asks "why did last sprint fail?" — Groq reads Hindsight memory context and answers from real team history. Conflict Predictor — Groq analyzes Hindsight observation consolidations and Neo4j patterns together to generate percentage delay risks per task before deadlines break. ``` js const response = await fetch( "https://api.groq.com/openai/v1/chat/completions", { method: "POST", headers: { "Authorization": `Bearer ${process.env.GROQ_API_KEY}` }, body: JSON.stringify({ model: "llama3-70b-8192", messages: [ { role: "system", content: systemPrompt }, { role: "user", content: userPrompt } ], temperature: 0.3 }) } ) ``` 🎙️ AI Voice Meetings Leader starts a meeting — FlowMind AI joins as a participant, transcribes speech in real time via Web Speech API, and when the meeting ends, Groq analyzes the transcript and auto-extracts tasks assigned by skill profile. Tasks appear on the board automatically. ⚠️ Conflict Predictor Reads Hindsight memory patterns and Neo4j relationship graph to flag delay risks per task before deadlines break. Not generic rules — actual team history powering the prediction. 🧠 Decision Log Every team decision stored with full context in Hindsight memory. AI recalls these to prevent repeated arguments in future meetings. 💬 AI Chat Full conversational access to complete team memory. Answers "what did we decide about X?" instantly from Hindsight recall. 📊 AI Insights Surfaces behavioral patterns: peak productivity windows, recurring bottlenecks, estimation biases — all derived from Hindsight observation consolidation and Neo4j graph traversal. 👤 Member Skill Profiles Members build profiles with skills, past experience, availability, and preferred task types. These get stored in both Hindsight memory and Neo4j. AI cross-references profiles against team outcomes to make assignments smarter over time. Multi-bank memory architecture was the right call. Separating per-user memory from shared team memory in Hindsight let the AI cross-reference individual skill profiles against team-wide outcomes. That cross-reference is what makes assignment reasoning genuinely useful rather than generic. Groq's speed changed what was possible. At under 3 seconds for full meeting analysis, the feature feels instant. If we had used a slower model, the voice meeting → task extraction flow would feel broken. Speed is a UX feature. Neo4j + Hindsight together is more powerful than either alone. Hindsight stores temporal patterns — what happened over time. Neo4j stores relationship patterns — who is connected to what. When both feed into Groq's context, the AI has both dimensions. That combination is what makes FlowMind's predictions feel eerily accurate. Cold start is a real problem. FlowMind is dramatically better after 2-3 projects. Week one predictions are weak because there's nothing in memory yet. We should have built a smarter onboarding flow that pre-seeds memory with team information before the first project starts. Web Speech API is inconsistent. Chrome works reliably. Safari doesn't. Firefox has partial support. We ended up using manual transcript input as fallback more than we expected. The lesson: always build the fallback first, make it feel intentional, not like a workaround. We underestimated the schema design for Neo4j. Getting the node and relationship types right for the knowledge graph took longer than building any feature. The graph schema is the hardest part of the Neo4j integration — plan it on paper before writing a single Cypher query. We were testing the voice meeting feature. Pasted in a transcript from a real college project meeting we'd had the week before. 3 seconds later, FlowMind said: "Assigned to Piyush — React listed in skill profile, 3 similar frontend tasks completed on time, prefers frontend work. Assigned to Debashree — research and documentation in past work experience, preferred task types include research." It read the room. From a transcript. Using memory it had built over previous sessions. That's when we stopped thinking of FlowMind as a hackathon project and started thinking of it as something real. 🔗 Live Demo: [https://flowwithmind.vercel.app/](https://flowwithmind.vercel.app/) 📁 GitHub: [https://github.com/piyushyenorkar/FlowMind](https://github.com/piyushyenorkar/FlowMind) Built at HackHazards '26 by Piyush Yenorkar and Debashree Mal Theme: Human Experience & Productivity Tracks: Neo4j · Render · Base44 · Sarvam · Expo