Mneme HQ / About
About

Architectural governance for AI‑assisted development.

Enforcing decisions before code is generated, not after drift reaches review.

Governance before generation. Not after review.

Mneme HQ is a lightweight architectural governance layer that helps coding agents follow your project's architectural decisions.

AI coding agents generate code at high speed but lack continuity with prior architectural decisions. As AI output scales faster than human review capacity, architectural drift becomes a major bottleneck.

Reviewer Bottleneck A chart showing AI code output rising sharply over time while human review capacity rises only slightly. The widening gap is the architectural drift problem. Mneme is inserted before review to evaluate output against constraints upstream. Volume / capacity → Time → 0 drift gap review can't keep up Mneme inserted before review AI code output Review capacity AI output scales faster than human review capacity. Mneme governs upstream.
Fig 01The reviewer bottleneck: AI output rises sharply, review capacity does not.

Mneme solves this by shifting governance left, enforcing decisions before code is generated rather than after drift reaches review.

How It Works

Mneme stores your project's architectural decisions, constraints, approved patterns, and anti‑patterns as structured, repo‑native governance records that live alongside your code.

It then deterministically retrieves the most relevant decisions, injects compact context into LLM prompts at generation time, and evaluates output against your architectural constraints before review.

Governance Flow Diagram A vertical pipeline showing six stages: codebase decisions, Mneme retrieval, constraint injection, coding agent, generated code, governance check. Mneme intervenes before code is generated and again before review. 01 Codebase decisions .mneme/ · governance records before generation 02 Mneme retrieval deterministic · decision-relevant 03 Constraint injection compact context into LLM prompt 04 Coding agent Cursor · Claude Code · Copilot 05 Generated code candidate output before review 06 Governance check evaluate against constraints
Fig 02The governance pipeline. Mneme intervenes upstream of generation and ahead of review.

Built for determinism and auditability, not opaque semantic memory layers.

Repo‑native by design

Governance records live in the repository as structured JSON, version‑controlled alongside the code they govern. The CLI retrieves matching decisions, evaluates output, and surfaces violations before review.

Repo-Native Governance Example A mockup showing the .mneme directory in a project tree, the contents of a project_memory.json governance record, and the output of running mneme check from the command line. project ▾ project/ ▾ .mneme/ project_memory.json decisions/ constraints/ anti_patterns/ ▸ src/ ▸ tests/ ▸ .git/ .mneme/project_memory.json { "id": "adr-014-event-bus", "status": "accepted", "decision": "All cross-service events publish via the central event bus.", "applies_to": ["src/services/**"], "anti_patterns": [ "direct service-to-service HTTP", "shared database writes" ] } terminal $ mneme check src/services/orders.py retrieving relevant decisions... → adr-014-event-bus matched scope: src/services/** → adr-007-error-envelope matched scope: src/services/** evaluating output... ✗ violates adr-014-event-bus found direct HTTP call to inventory-service expected: publish via event bus governance check failed · 1 violation · before review
Fig 03A governance record, the directory it lives in, and a check that catches a violation.

Why this matters

Without enforced architectural continuity, AI‑assisted development drifts. Patterns diverge across iterations. Frameworks conflict. Reviewers absorb the cost. With governance enforced upstream, decisions stay aligned across sessions, contributors, and agents.

Architectural Drift Visualisation Two panels comparing AI-assisted development without Mneme versus with Mneme. Without Mneme, patterns diverge across iterations and drift accumulates. With Mneme, decisions stay aligned across iterations. Without Mneme Drift accumulates ITERATION → 01 02 03 04 05 06 Inconsistent patterns Conflicting frameworks Reviewer overload Drift accumulation With Mneme Architecture stays aligned ITERATION → 01 02 03 04 05 06 Aligned decisions Continuity across sessions Enforced constraints Stable architecture
Fig 04Drift accumulates without enforcement. With Mneme, architecture stays aligned.

Our mission

To give teams reliable architectural continuity across sessions, contributors, and agents, so they can scale AI‑assisted development without losing architectural consistency.

What Mneme is not

Mneme is positioned deliberately. It is not:

  • An AI memory tool or prompt persistence layer.
  • A general‑purpose context manager for chat sessions.
  • A RAG or vector database for code retrieval.
  • A rules file replacement that documents standards without enforcement.

Rules files document standards. Mneme enforces them.

Memory tools recall context. Mneme governs implementation.

RAG retrieves knowledge. Mneme operationalises decisions.

Get involved

Mneme HQ is built openly, in public, and grounded in real implementation work on production systems. If governance, continuity, or reliability for AI‑assisted development workflows is something you care about, get in touch.

GitHub github.com/TheoV823/mneme
Founder Theo Valmis
Roadmap Public roadmap
Insights Technical writing
Contact mnemehq.com/contact

Ready to enforce your architecture across every AI coding session?

View on GitHub See use cases