u/killerexelon

I’ve been building Mnemo as a side project — it gives AI coding agents persistent memory so they stop forgetting everything between sessions. No cloud, no API keys, fully local.

The problem it solves:

Every new chat session, your AI agent has zero context. You re-explain your architecture, re-discover the same bugs, re-teach the same conventions. Mnemo fixes this by silently capturing decisions as they happen, building a knowledge graph of your codebase, and injecting the right context when the next session starts.

Where it’s at today:

Published on PyPI, npm, Homebrew, and VS Code Marketplace
222 tests, 58 tools, supports Cursor, Claude Code, Kiro, Amazon Q, Copilot
Semantic search in 2ms, knowledge graph across 14 languages, natural memory decay
Works with any MCP-compatible agent

Why I need help:

I built this solo alongside a full-time job, so I can’t give Mnemo all the time it deserves. The core works well and is stable, but I’ve mostly tested it against my own workflows and projects. What I really need is more people running it in different environments — different languages, different AI clients, different project sizes — to validate that it holds up broadly. I want confidence that it’s built not just that it works for me.

What I’m looking for:

Testers — try it on your projects, report what feels off, what breaks, what’s confusing
Code reviewers — look at the architecture, the search logic, the graph model — tell me what you’d do differently
Python contributors — core engine, search ranking, graph algorithms
TypeScript — dashboard UI, VS Code extension improvements
Docs & DX — making it easier for new users to get started
Ideas — if you use AI coding agents daily, your perspective shapes what gets built next
No massive time commitment needed. Even trying it once and sharing your experience helps.
Stack: Python • Kuzu (graph DB) • ONNX Runtime • tree-sitter • NetworkX • PyInstaller

Links:

GitHub: https://github.com/Mnemo-mcp/Mnemo
License: AGPL-3.0

Drop a comment, open an issue, or just star the repo if it’s interesting to you. Happy to onboard anyone who wants to dig in.

Anthropic recently published their harness design for long-running apps - a multi-agent architecture inspired by GANs where a Generator builds code and an Evaluator critiques it in a loop.

I built my own version using Kiro CLI and used it to generate a marketing website for my project Mnemo (persistent memory for AI coding agents).

The architecture:
Planner (runs once) → Generator ↔ Evaluator (12 iterations)
Each agent is a separate CLI process with zero shared context. They communicate only through files (spec.md, eval-report.md). The Evaluator uses Playwright to actually browse the live site - not just read code.

What made it work:

Clean slate per invocation — each agent starts fresh, reads only its input files. Prevents context anxiety.

Playwright MCP for testing — the evaluator navigates, clicks, resizes viewports. Catches visual bugs code review never would.

Anthropic's frontend design skill — explicitly penalizes generic AI patterns (Inter font, purple gradients, card layouts). Forces creative risk-taking.

Continuous iteration, not retry-on-failure— all 12 rounds run regardless. Each one improves.

The progression was wild:
Iteration 1: Exactly what you'd expect from AI - functional but forgettable

Iteration 4: Generator pivoted to "Terminal Noir"
IBM Plex Mono, amber on black, grain textures, scanlines. This is the kind of creative leap that doesn't happen in single-shot generation.

Iterations 5-12: Polish, accessibility, responsive fixes, reduced-motion support

Stats:
Total time: 3h 20min
Iterations: 12 (generator + evaluator each)
Manual code written: 0 lines
Tech: Next.js, Tailwind, Framer Motion, TypeScript

Live result: https://mnemo-mcp.github.io/Mnemo/

Key takeaway: The model is the engine. The harness, the constraints, feedback loops, and adversarial structure around it, what determines whether you get AI slop or something genuinely distinctive.

Happy to answer questions about the architecture or share the prompt files.

This is what your codebase actually looks like.

2032 nodes. 2878 edges. 7 relationship types.

Every service. Every dependency. Every API. Every owner. Every connection your team built over years — visualised in one graph.

Most AI coding assistants see none of this.

They see the file you have open.
Maybe the files you paste in.
Nothing else.

So when they generate code, they generate it blind.
No knowledge of what depends on what.
No knowledge of what breaks if you change something.
No knowledge of the relationships your team spent years building.

This is the real problem with AI in enterprise development.
It's not capability. The models are powerful.

It's context. AI operates on a fraction of the knowledge your senior engineers carry in their heads.

Mnemo builds this knowledge graph automatically from your codebase.

Services and their boundaries.
APIs and their consumers.
Dependencies and their blast radius.
Files and their owners.
Decisions and their history.

And then makes all of it available to your AI assistant — automatically, on every session.

No more blind generation.
No more code that compiles but breaks something downstream.
No more AI that doesn't know why things are the way they are.

This is what AI-assisted development should actually look like.

🔗 github.com/Mnemo-mcp/Mnemo

Drop a comment if you've ever had AI break something it didn't know existed.