Memento

Memento gives your codebase a brain. It's an org-level memory layer that captures engineering context automatically from Claude Code session transcripts, pull requests, and your legacy docs.

Comment

Inspiration

Every engineering team has the same problem: the code survives, but the context doesn't. Why was this architecture chosen? What was tried and abandoned? What constraints forced this design? That knowledge is scattered across engineers in different teams, and goes stale quickly as features are layered on top of each other.

The problem is getting worse, not better. As AI coding assistants write more of our code, the context behind decisions is increasingly trapped in ephemeral chat sessions that vanish when the terminal closes. Onboarding a new engineer takes months of reconstructing decisions made a year ago — assuming the person who made them is still on the team. As a result, the same mistakes get repeated, settled decisions get re-litigated, and every PR cycle pulls a senior engineer away from their own work.

We built Memento because we believe a codebase should have a memory — one that both humans and AI tools can query.

What it does

Memento is an org-wide memory layer for engineering teams. Each organization gets its own AI assistant backed by a persistent memory layer, and Memento captures context automatically from the places engineering knowledge actually gets created:

Memento captures context automatically from the places engineering knowledge actually gets created:

  • Claude Code session transcripts are automatically imported into org memory via a session-end hook — the reasoning behind every AI-assisted change is preserved, not lost when the session ends.
  • Pull requests trigger a CI hook that condenses all session history connected to that branch into distilled context about the feature.
  • Existing documentation can be uploaded for legacy codebases. An LLM pipeline identifies gaps and inconsistencies between the docs and the actual codebase, then asks the user targeted questions to close those gaps, so stale docs become living knowledge instead of misinformation.

Users query context from Memento without leaving their workflow:

  • Claude Code MCP integration — Claude Code gets direct access to the memory layer plus git history (including a custom GitHub GraphQL tool for git blame), so context flows straight into your coding session without switching chats. A dedicated context-review tool means that every time Claude suggests a change, it first checks past context to make sure the change is consistent with the existing vision, unless the user is explicitly setting a new one.

How we built it

  • A one-command Claude Code hook plugin captures session transcripts and ships them to our ingest endpoint.
  • A GitHub webhook receives PR-merge events and matches each PR to the Claude Code sessions that produced it.
  • Closed-world LLM calls distill each PR + its Claude Code transcripts into structured, source-cited decision records.
  • Leveraged the Backboard.io API for persistent memory + semantic search, document upload + RAG, ElevenLabs speech-to-text, and LLM access.
  • An interactive memory graph renders decision nodes and the typed relationships between them (react-force-graph).
  • A custom MCP server exposes tools that let Claude Code pull Memento's context back into its own sessions.
  • WebSockets stream live graph traversal to the browser, animating each hop as the assistant reasons over memory.

What we learned

  • Anchor the process to the outcome. Sessions wander as engineers change direction, so we distill context by matching the transcript against the PR diff — keeping only reasoning that maps to shipped code.
  • Integrate product into the existing user workflow to minimize adoption friction. Engineers already explain their reasoning to Claude Code while building, so we harvest it in the background instead of running interviews.
  • Build shared, composable primitives. Our GitHub tools, context engine, and graph tools were built once and reused across pipeline, MCP, and Q&A.
  • Surface data gaps instead of hiding them. Stale-node flags and hedged answers build trust — better to admit a gap than confidently give a wrong answer.

What's next for Memento

  • Ticket creation and tracking integration. Memento currently remembers the past — integrating with ticketing closes the loop on the future. Users can plan upcoming development in conversation with the assistant, and Memento both stores that planning context and creates the tickets, so intent is captured and directly guides development.
  • Deeper analytics on knowledge gaps. Surfacing which parts of the codebase have the thinnest context, so teams can shore up those gaps before they turn into risky changes and slow debugging.
  • Support context input from more ADEs. We currently only retrieve context from Claude code through a custom hook, but we should add support for more ADEs such as Cursor, Codex, etc. to accommodate for the preferences of all developers.

Built With

  • auth0
  • backboard.io
  • claude-code
  • elevenlabs
  • fastapi
  • fastapi-hackplate
  • github
  • mongodb
  • python
  • react
  • react-force-ui
  • react-query
  • resend
  • vite
  • webhooks
Share this project:

Updates