Rewind is a memory debugger for Cognee-backed AI agents: DevTools for AI memory. Agents with memory are black boxes; when one answers wrong you cannot see what it knew, where the answer came from, or when it learned it. Rewind renders the full Cognee knowledge graph as a live force graph, X-rays every answer by highlighting the exact nodes and edges the retrieval used, and adds time travel: drag a timeline slider and questions are answered only from memory as of that point. The demo ingests the first 45 issues and PRs of the Cognee repository itself (292 nodes, 859 relationships), but the pipeline works with any GitHub repository.

Aeg is a memory immune system for AI agents, built on cognee 1.2.2 open source. AI agents with long-term memory believe whatever gets written into it: one poisoned document or one compromised tool silently rewrites what the agent knows, and a vector-plus-graph stack cannot tell a corroborated fact from an injected lie. Aeg is the missing immune layer — a FastAPI gateway in front of any cognee-backed agent that makes memory earn its place and heals itself when attacked. Cognee is the load-bearing engine, not decoration: every cognee call lives in one auditable file, and cognee 1.2.2's behavior was empirically verified with an 18/18 truth-check before any feature code. remember() runs screened, provenanced ingest, cognifying clean content with node_set facets for source and trust while injection-carrying content is blocked before it is cognified. recall() does triple duty: it answers the agent's questions over graph lanes, proves healing by asserting a recall_diff actually changes output, and answers a 2-hop join only the graph lane can. forget() is two-tier — reversible quarantine, then permanent removal after an LLM gate — while improve() bridges a verification note into the permanent graph. Defeated attacks become antibodies: an exact replay is blocked instantly at ingest, and a local embedding match catches reworded ones, no LLM call. A live dashboard walks a poison-to-heal cycle with a real-time health score; an MCP server and per-user access control also ship, flag-gated.

Engram, the autonomous memory dashboard. Every time you call an LLM, it wakes up with amnesia. Memory tools try to fix this by appending everything they hear, but that just piles up contradictions: the model ends up "knowing" you use both Postgres and Supabase, and confidently recalls the stale one. Engram is a self-organizing memory layer built on Cognee that treats memory as a lifecycle with an opinion about truth over time. It ingests mixed context (GitHub repos, PDFs, articles, YouTube transcripts, chat exports, and free-text notes) into a living knowledge graph, then does three things most memory tools do not: Reconciles contradictions: it detects when new information supersedes or conflicts with what you already know and lets you resolve it (keep new, keep old, or keep both). Forgets on its own: unreinforced facts decay in confidence and are automatically pruned, so the store stays clean. Answers across time: graph-grounded recall with "what changed since X?" diffs, confidence timelines, and a morning-after Recap. It also exposes its memory to any agent over MCP (read and write), so agents can learn across runs.

AI coding assistants with persistent memory of ADRs, postmortems, and incident history keep recommending superseded decisions long after the underlying assumption is proven wrong. Nothing tracks which past outputs are now suspect once that fact changes. MemoryScope is npm audit for AI memory. Built on Cognee, it logs every answer with the exact chunk_id/data_id it cited into an external SQLite recommendation log. When a fact is corrected with forget(), MemoryScope walks that log and flags every dependent answer as suspect, showing the blast radius (how many past answers a correction invalidates) before you commit. Re-asking returns the corrected answer; the old row stays auditable. The suspect flag cannot hallucinate: no model produces it. It is a deterministic join between the citation log and a forget() event.

FALSIFY — the AI that revises, not forgets. Every memory layer bolted onto an LLM today is an append-only pile of facts. It can remember, but it cannot un-believe. When new evidence proves an old fact wrong, RAG keeps citing the stale fact forever, and naive "delete the memory" throws away the fact AND every conclusion built on it — a lobotomy, not a revision. This is belief-level amnesia: the AI confidently remembers something that's been proven false, and every downstream conclusion inherits the lie. FALSIFY treats a research inquiry as a living belief graph of typed, stateful nodes — Hypothesis, Evidence, Conclusion — wired by dependency edges, all stored in Cognee. When a new fact contradicts existing evidence, FALSIFY performs belief revision ON the graph itself: 1. Refute — the contradicted Evidence flips to truth_state = REFUTED. 2. Propagate — a grounded least-fixpoint traversal cascades the refutation along depends_on edges, INVALIDATING every conclusion that critically rested on it (correct for chains, diamonds, non-critical support, and cycles). 3. Re-ignite — the losing Hypothesis is demoted to SUPERSEDED; the strongest surviving rival is promoted as the new frontier. 4. Surgically forget — orphaned dead-ends are hard-deleted from BOTH the graph and the vector store, while the refuted fact is KEPT as provenance so the graph always explains WHY it changed. 5. Persist — truth-state is written ON the node, so the next session's recall() skips the dead branches automatically. Every run prints a live A/B scoreboard: FALSIFY (revised) answers "Company X knew by Jan 2021" while a plain-RAG baseline over the same store still cites the refuted March report [STALE]. Same store, same query — FALSIFY revised its belief; RAG could not. The hackathon asks "Where's my context?" FALSIFY's answer: the context wasn't lost — it was WRONG, and the AI should revise it, not blindly recall it. Runs in ~2 minutes on fully self-hosted, zero-external-service Cognee (LanceDB + graph engine + SQLite). Ships with an offline keyless demo mode for instant judging — or plug in any LLM API key to unlock live contradiction detection, where an LLM judges whether new evidence genuinely conflicts with existing beliefs before triggering the revision cascade. Includes an 11-test suite that requires no API key.

GroundTruth: Belief-Maintenance Memory for LLM Agents Most AI agents wake up with amnesia. Long-running ones face an even tougher problem: their memory is append-only. Because their memory only grows, they continually cite facts that have since been retracted, superseded, or disproven. GroundTruth solves this by adding a belief-maintenance layer to LLM memory. Built on the open-source Cognee runtime, it gives memory a dynamic lifecycle: every belief carries evidence and can be contested, superseded, or surgically forgotten. It implements Cognee’s four foundational verbs against real code: Remember: Ingest claims alongside their evidence. Recall: Generate answers complete with evidence annotations. Improve: Contested claims are adjudicated via a continuous feedback loop. Forget: Execute authority-driven and adjudicated supersession. The Benchmark Results Tested against a real corpus of retracted papers (sourced from Retraction Watch and Crossref): Accuracy: Out of 20 questions, a naïve append-only memory cited retracted originals in 18 answers. GroundTruth cited them in 0, while perfectly retaining all 5 valid controls (25/25 retraction coverage, 0 integrity violations). Conflict Detection: Achieved a semantic conflict detection score of 1.00 Precision and 0.67 Recall. Try the Live Demo: https://groundtruth.gudman.xyz

# MemoryOS: One Memory. Infinite Thinking Modes. ## 🚀 The Inspiration Have you ever spent an hour teaching an AI the architecture of your codebase, only to start a new chat the next day and realize it has forgotten everything? Or perhaps you used an AI to research a complex machine learning concept, but when you switched to your coding AI assistant to implement it, the two agents couldn't talk to each other? Today’s AI agents suffer from two fatal flaws: **Amnesia** (they forget what you teach them between sessions) and **Silos** (they cannot share knowledge with other specialized tools). We spend more time re-explaining context than actually building. We built **MemoryOS** to eliminate this problem entirely. Once your AI stops forgetting, the ceiling on what you can build together completely disappears. ## 🧠 What It Does **MemoryOS** is a persistent cognitive operating system powered by a self-evolving knowledge graph. Instead of relying on isolated chat sessions, MemoryOS gives you **one centralized memory** and **multiple specialized AI modes** to reason over it. If you teach the "Developer Specialist" about your unique backend architecture today, the "Learning Specialist" can seamlessly recall that exact architecture tomorrow to help you study system design. **Key Features:** * **Graph-Based Persistent Memory:** Powered by Cognee, combining Kuzu (Graph) and LanceDB (Vector) to ensure knowledge survives across sessions. * **Multi-Specialist Orchestration:** Dynamically routes queries to different reasoning modes (Developer, Learner) that all share and enrich the same underlying knowledge base. * **Self-Evolving Intelligence:** Using the `improve()` pipeline, the system actively cleans its own memory in the background—merging duplicate concepts and discovering new relationships between isolated facts. * **Full Code File Ingestion:** Drag and drop entire repositories. The system ingests and maps the architecture for complete contextual understanding. * **Live Context Tracing & Graph Visualization:** A stunning glassmorphic UI that visually maps out the AI's "brain," showing you exactly how many "hops" it took to retrieve an answer and which concepts are connected in real-time. ## 🛠️ How I Built It MemoryOS was built to be fast, extensible, and visually stunning: * **Intelligence Layer (Cognee):** We deeply integrated Cognee as our memory engine. We built a custom `cognee_adapter` that bypasses standard setups to dynamically route LLM and embedding tasks through **Google Gemini** (`gemini-2.5-flash`). * **Backend Framework (FastAPI):** A robust asynchronous Python backend handles multi-specialist routing, session metadata tracking, and the memory ingestion pipeline. * **Frontend UI:** A custom, dark-mode, glassmorphic HTML/JS interface designed from scratch. We prioritized a premium aesthetic with smooth micro-animations, interactive memory cards, and a real-time SVG knowledge graph. We also embedded dynamic Mermaid.js architecture diagrams directly into an integrated tech blog. * **Workflow Engine:** A specialized routing engine that intercepts user inputs, classifies intent, and seamlessly dictates whether to trigger a `remember()` (store fact) or `recall()` (answer question) flow. ## 🚧 Challenges I Ran Into * **State Synchronization:** Ensuring that multiple specialized agents could read and write to the same Cognee graph simultaneously without causing context collisions or metadata overwrites. * **Hallucination Control:** Moving beyond standard vector RAG was difficult. We had to fine-tune our graph traversal so the AI retrieves deep, multi-hop context instead of just pulling the most semantically similar text chunk. * **UI/UX Complexity:** Visualizing a complex, evolving knowledge graph in real-time in the browser without overwhelming the user or causing performance bottlenecks required several iterations of our custom frontend rendering. ## 🎉 Accomplishments That I'm Proud Of * **The `improve()` Proof:** We successfully proved that one agent's learning feeds another's. Asking the Developer a coding question and then asking the Learner a conceptual question yields answers synthesized from *both* interactions. * **Bypassing OpenAI Dependencies:** We successfully hooked Cognee entirely into the Gemini ecosystem for both fast reasoning and dense vector embeddings. * **The Aesthetic:** We didn't just build a functional backend; we delivered a beautiful, production-ready, glassmorphic UI that feels incredibly premium and responsive. ## 📚 What I Learned We learned that the future of AI isn't about making a slightly smarter model; it's about giving models **better memory infrastructure**. When you shift the paradigm from "chatting with an AI" to "building a shared brain with an AI," the possibilities for complex, long-term collaboration increase exponentially. ## ⏭️ What's Next for MemoryOS This is just the MVP. Our roadmap includes: 1. **More Specialists:** Adding Research and Planner specialists to the workflow engine. 2. **Multi-Project Scoping:** Advanced workspace partitioning so users can manage distinct graphs for entirely separate companies or domains. 3. **Full Graph Explorer:** Expanding the live visualization into a fully interactive 3D explorer where users can manually edit, sever, or create new neural pathways in their AI's memory.

Medical records store information. Anamnesis remembers the patient. A patient's history is scattered across blood reports, prescriptions, discharge summaries, and imaging. Every visit starts with a doctor reconstructing the past instead of treating the present. Anamnesis turns that pile of documents into a living, connected clinical memory: upload a report, and it becomes part of a knowledge graph that links diagnoses, medications, labs, and visits together, growing more useful with every new fact. It's built entirely on self-hosted Cognee (Docker locally, GCP in production, using all four of its memory primitives: * Remember - ingests documents (PDFs, scanned prescriptions, reports), extracts structured medical entities via Gemini vision-based OCR, and commits them to the patient's memory graph. * Recall - answers a clinician's question by retrieving connected clinical context, with traceable evidence chains back to source documents — not by searching documents directly. * Improve - re-processes the graph as clinicians correct facts (ruling out a diagnosis, discontinuing a medication), restructuring relationships to reflect reality. * Forget - intelligently retires duplicate or superseded documents (e.g., a re-uploaded blood report) without losing the historical record. Every one of these operations is visible in a live operations panel in the app — Anamnesis is designed through Cognee, not around it. Beyond the memory engine, it ships a full clinical workflow: a unified patient dashboard with an interactive live memory graph, a clinical timeline and history archive, multi-format document ingestion with vision OCR, a natural-language recall assistant, and multi-tenant onboarding via Clerk Organizations, all backed by Postgres + pgvector (vector store) and embedded Kuzu (graph store), with patient data never leaving infrastructure we control.

EthicsGraph is a full-stack AI ethics case-law memory and recall system designed to help developers evaluate new AI designs against historical ethical precedents. Built on top of Python FastAPI, React (Vite), and the open-source Cognee library, the project manages an ethics knowledge graph using Cognee’s high-level lifecycle API (remember, recall, improve, forget). Key Features: - Log Case (Remember): Ingests past ethical incidents (biases, privacy leaks, safety concerns) into a unified dataset using tagging (`node_set=["ethics_case", domain]`) to support cross-precedent graph reasoning. - Design Review (Recall & Improve): Evaluates new AI system architectures by recalling similar semantic contexts from the Cognee graph, utilizing an LLM agent to classify matching analogous cases. The system refines matches based on user feedback (calling `cognee.improve`). - Precedent Audit (Forget): Automates compliance auditing by identifying outdated, overturned, or superseded precedents, and prunes them dynamically from active graph memory via `cognee.forget`. Stack: Python FastAPI, SQLite, React (Vite), Glassmorphic CSS, Cognee Open Source.

MemOps is an autonomous, self-improving institutional memory and SRE incident correlation engine powered by Cognee Cloud. In modern cloud environments, engineering organizations leak millions of dollars in downtime due to "institutional amnesia"—when an SRE changes teams or goes off-shift, the architectural context behind past 3:00 AM outages disappears. Unlike generic chatbots or flat vector RAG systems that fail at complex multi-hop causation (PaymentGateway -> AuthToken -> RedisEviction), MemOps transforms unstructured incident runbooks, Slack logs, and architecture diagrams into a permanent, time-aware hybrid knowledge graph. Key Innovations: Interactive 3D WebGL War Room: A client-side Three.js & Framer Motion force-directed graph that renders microservice topologies and simulates sub-millisecond blast-radius failure cascades in real time. ContextFirewall MCP Server: A native Model Context Protocol (MCP) middleware server with 6 tools (get_trusted_context, audit_context, remember, forget_memory, improve_rules) providing 4-tier security auditing (Staleness, Contradiction, Secret Redaction, Trust Scoring) directly into Claude Code and Cursor. Deterministic Ontology Enforcement: Uses formal RDF Turtle ITIL ontologies (itil_subset.ttl parsed via rdflib) to validate graph structure and eliminate LLM schema hallucinations during ingestion. Intent-Driven Cognitive Routing: Exposes 10 distinct Cognee search primitives (GRAPH_COMPLETION_COT, TEMPORAL, TRIPLET_COMPLETION, HYBRID_COMPLETION, etc.) dynamically mapped to SRE investigation modes.

Revenant is a cognitive social memory engine and RPG gameplay world where NPCs possess persistent, evolving, and interconnected memories, powered by a live Cognee Cloud knowledge graph. NPCs in games have been stateless since 1980, resetting completely on restart. Revenant fixes this by mapping NPC minds to a shared Cognee Cloud graph database. When players converse, trade, betray, or gift, these events are stored as semantic facts. If you betray Silas the Blacksmith, he runs a background "Rumor Mill" that propagates warning edges to other NPCs. When you later approach Kael the Guard Captain, he greets you with immediate suspicion, referencing Silas's warning via multi-hop graph citation. Core Features: 1. 3D Isometric Voxel World: A playable RPG scene built with Three.js (React Three Fiber) with camera-relative WASD movements. 2. Zone of Truth (Lore Fact-Checker): Players can cast a Truth spell (for 10 Gold) to check claims against the NPC's actual memory graph and core backstory using Gemini 2.0 (returning TRUE, FALSE, or UNKNOWN with reasons). 3. Session Telemetry & Cost Audit: Exposes real-time token audits, active models, and cumulative USD cost directly from Cognee Cloud's /api/v1/sessions/{id} endpoint in a gold-framed HUD overlay. 4. Surgical Amnesia Spell: Erases memories at document_id granularity via Cognee's forget() endpoint, verifying the deletion live. 5. Real-Time Knowledge Graph: An interactive 2D force-directed canvas displaying real-time node connections, trust links, and rumor paths over WebSockets.

Patient Zero is an AI-powered misinformation lineage tracing system that permanently remembers how a claim evolves over time and traces it back to its verified primary source. Instead of only checking whether a claim is true or false, Patient Zero reconstructs the complete mutation history of a claim, identifies where factual drift occurred, classifies the type of misinformation, and visualizes the entire propagation chain using Cognee's persistent knowledge graph. The project demonstrates how long-term AI memory can help society preserve factual context instead of repeatedly forgetting the origin of misinformation.

COGNEE-Vault is a privacy preserving security layer built on top of Cognee Cloud. While Cognee is excellent for giving AI agents a permanent memory, storing sensitive data (like API keys, passwords, or personal user data) in a plain-text cloud graph poses a security risk. Vault solves this by acting as a secure gatekeeper before data ever reaches the cloud. Key Features: Smart Routing: Intercepts AI memory requests and classifies the data. Safe data is sent directly to Cognee Cloud for full graph-vector processing. Local Encryption: Sensitive data is caught, encrypted locally using AES-GCM, and stored in a secure on-premise SQLite vault. Plain-text secrets never touch the cloud. Searchable Encryption: Uses a cryptographic Trapdoor Index, allowing the AI to successfully query and retrieve its encrypted secrets without exposing the raw text to the database search engine. Cryptographic Erasure: When cognee.forget() is called, Vault destroys the AES master key, making the sensitive data instantly and permanently unrecoverable. Seamless Integration: Automatically merges local decrypted secrets with Cognee Cloud's public graph results, ensuring the AI agent experiences one unified memory stream.

WeakSpot A memory that knows what you keep getting wrong — and when you've finally got it. The Problem Grinding DSA problems for interviews has a quiet flaw: you forget your own mistakes. You solve 200 problems, mark them done, and a month later make the exact same logical slip on the same pattern — because nothing in the typical workflow remembers why you got something wrong last time, only that you eventually solved it. Spaced-repetition trackers tell you when to revisit a problem. None of them reason over the actual content of your past mistakes, or know when to stop warning you once you've genuinely moved past them. The Solution WeakSpot is a personal coding-practice memory tracker that closes that loop. Every time you log a mistake, you write it in your own words — not a generic "solved/failed" tag, but the actual logical slip. Before starting a new problem on that pattern, WeakSpot recalls your own past mistakes and surfaces a short warning. Once you've proven mastery with consecutive solves, the warning is actively forgotten — not just buried under a lower score, but removed, so your memory stays focused on what's actually still a weak spot today. This is built entirely on Cognee's four memory lifecycle operations, used as the core engine rather than a bolted-on feature: remember() — ingests user-authored mistake notes, tagged by pattern (sliding window, two pointers, DP, graphs, etc.), into Cognee Cloud's hybrid graph-vector memory recall() — before a new attempt, queries memory for related past mistakes on that pattern and returns them via semantic + graph-based retrieval improve() — reweights the graph after each session: repeated failures reinforce a weak-spot signal, three or more consecutive solves flag a pattern as mastered forget() — once a pattern is mastered, actively prunes the weak-spot flag, so recall() comes back clean instead of resurfacing stale warnings A deliberate design decision runs through the whole system: Supabase handles cold-start structure — stats, streaks, attempt history — while Cognee only ever ingests things that genuinely need semantic memory: a human's own description of a mistake. Auto-generated or imported data never touches the graph, because Cognee's value comes from reasoning over specific, real reasoning failures, not filler text. Tech Stack Frontend: Next.js, Tailwind CSS, deployed on Vercel API layer: Node.js, Express, TypeScript, Prisma Database: Supabase (Postgres) — auth, billing state, usage limits, structured attempt history Memory layer: Cognee Cloud — managed hybrid graph-vector memory LLM: Google Gemini 2.5 Flash — powers both Cognee's internal reasoning and the app's answer-formatting layer Auth: JWT-based signup/login Billing: Razorpay (test mode) with a Free (BYOK) / Pro (managed key) tier split Current State The core Cognee memory loop — log a mistake → recall a warning → improve the graph → forget a mastered pattern — is live and working end to end on the deployed app. The Free-tier BYOK flow is fully functional. Billing via Razorpay is wired up in test mode but not fully complete given the build timeline; it was deprioritized in favor of getting the full memory lifecycle working correctly, which was the actual focus of this build. What We'd Build Next Deeper improve() logic driven by real usage signals over time rather than a fixed consecutive-solve threshold, richer pattern taxonomy beyond the current 8 canonical categories, and a completed billing flow so Pro tier is fully self-serve.

CogneeVerdict is a next-generation AI-assisted legal intelligence and analytics platform. It functions as an adaptive, graph-powered co-pilot that helps investigators, defense attorneys, and prosecutors analyze raw, unstructured case dossiers (such as witness statements, forensic reports, and timeline logs) to build cohesive, explainable theories of a case. Rather than acting as a standard, passive document-search chatbot, CogneeVerdict transforms unstructured legal text into a persistent semantic memory network that continuously learns, quantifies credibility, and tracks factual contradictions over time.

Nyra is a voice assistant for Raspberry Pi, built with LiveKit Agents and designed to do what typical smart speakers cannot: remember you across sessions and stay conversational while work runs in the background. It uses Cognee as a persistent knowledge graph recall() injects your facts before every reply, remember() ingests conversations and files, improve() consolidates session learnings, and forget() lets you prune stored data. Hermes handles slow tasks like research and browsing asynchronously, so Nyra keeps talking instead of going silent. The hardware, Wake-word activation, realtime speech-to-text and text-to-speech, and a status UI complete a voice-native realtime memory system built for this hackathon.

Smriti (स्मृति) is an incident memory system for DevOps teams, built on Cognee Cloud. Every engineering team has that one senior engineer who "remembers everything." When an incident hits, they instantly recall a similar one from months ago and its fix. Smriti makes that institutional memory permanent and shared, instead of living in one person's head. Resolved incidents flow in automatically through a signed webhook (no manual entry) and are remembered as a knowledge graph connecting incident to service to symptom to root cause to fix to engineer. When a new alert comes in, Smriti recalls the closest matching past incident, grounded in the graph, with its root cause and the fix that worked. The project uses all four Cognee memory operations as real, load bearing features rather than a checkbox. remember() ingests every resolved incident automatically. recall() powers the core "have we seen this before?" matching. improve() consolidates memory to surface recurring patterns (for example "PaymentService: 4 memory incidents this quarter, chronic issue"). forget() lets stale incidents (deprecated services, obsolete fixes) be pruned so recall stays accurate. Built with Next.js and Cognee Cloud (zero self hosted infra), with GitHub auth plus a guest mode, an interactive force graph UI with light and dark themes, and a security layer covering HMAC webhook verification, zod validation, rate limiting, and admin gated destructive operations. Submitted on the Cognee Cloud track, with an accompanying blog post for the Blog bounty. Built with AI assistance (Claude, for code generation and design iteration) working from specs, architecture, and security requirements I defined and reviewed.

SessionZero is a trust-weighted memory layer for AI coding agents, built on Cognee's real knowledge-graph lifecycle. Most memory tools solve recall but not trust — they hand back an outdated or contradicted memory with the same confidence as a current one. SessionZero scores every recalled memory on four signals (path, similarity, recency, contradiction) before it ever reaches an agent, so stale decisions get flagged instead of blindly repeated. It includes a live dashboard, a real Claude Code hook integration, and a full remember/recall/forget lifecycle running against a live Cognee Cloud tenant — 16 real memories, verified with a real 0.31-vs-0.97 confidence gap on a contradicted decision.