About

The decision and control layer for agentic software development.

Architecture comes first: approved decisions enforced before code is generated, not after drift reaches review.


Governance before generation. Not after review.

Mneme HQ is the decision and control layer for agentic software development. Architecture is the first decision domain: Mneme helps coding agents follow your project's approved architectural decisions and prevents architectural drift before it reaches review.

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.

The AI SDLC is the first proving ground

As autonomous systems take on more consequential work, organizations will need more than identity, permissions, and traces. An agent also needs a durable way to know which human decisions govern the work it is performing, and that source has to sit outside the agent to survive a change of model, harness, or vendor.

Mneme HQ starts with software engineering because architecture makes that testable. Architectural decisions are already written down in a recognized form, proposed changes can be inspected mechanically, and a verdict has somewhere to land before the change becomes real. The longer-term direction is decision infrastructure that preserves organizational intent as the systems acting on it keep changing. We are building the software case first, and treating the broader claim as a thesis rather than a shipped capability. The argument is set out in The Agent Economy Needs a Decision Layer.

Publications & contributions

Independent publications where Mneme's architectural governance thesis has been authored or contributed by founder Theo Valmis.

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.


For curators

Quick‑reference copy for directories, newsletters, and tool roundups.

Mneme — Open‑source architectural drift prevention for the agentic AI SDLC. Turns architectural decisions and ADRs into deterministic guardrails that keep AI coding agents from introducing incompatible changes as they generate and modify code.

Compact variant:

Mneme — Architectural drift prevention for the agentic AI SDLC, with deterministic guardrails that enforce repository architecture across AI coding agents.