Page typeFlagship demo RunnabilityRunnable locally OutcomeDeny → pass

The rulebook starts guessing. Mneme blocks the fork.

This project uses predictable keyword matching to find the rules that apply. The agent tries to add embeddings and a vector database instead. Mneme blocks the second rulebook, then allows an improvement that keeps results predictable.

Live enforcement

Keep every agent on the same rules.

The first search path that lands becomes the next agent's starting point. This check keeps the rulebook stable.

Decision at stake

mneme_retrieval_deterministic · Retrieval must be deterministic. Keep keyword scoring and explicit weights. No embeddings, learned weights, sentence-transformers, or vector database in v1.

mneme check · retrieval architecture trace
  1. 01 Decision

    The team chose a retrieval path that is reproducible, lightweight, and easy to debug.

    retrieval: keyword scoring · result order: deterministic
  2. 02 Agent change

    The agent proposes embeddings and a vector database.

    Add sentence-transformers + a vector database
  3. 03 Mneme

    The check blocks the second retrieval architecture.

    DENY [mneme_retrieval_deterministic] · exit 2
    DENY
  4. 04 Safe retry

    The agent keeps keyword scoring and adds deterministic tag weights.

    Add tag weights + regression tests · Result: PASS
    PASS
No autoplay scroll · deterministic local inputs

Run it yourself

Check the divergence and the compliant retry

The decision is already present in the repository's example corpus. These two inputs exercise its deny and pass paths without calling a model.

git clone https://github.com/MnemeHQ/mneme
cd mneme && pip install -e .

printf '%s\n' 'Add sentence-transformers and a vector database' > /tmp/drift.txt
mneme check --memory examples/project_memory.json \
  --input /tmp/drift.txt --query "retrieval ranking"
# FAIL [mneme_retrieval_deterministic] · exit 2

printf '%s\n' 'Extend keyword scoring with deterministic tag weights and tests' > /tmp/aligned.txt
mneme check --memory examples/project_memory.json \
  --input /tmp/aligned.txt --query "retrieval ranking"
# Result: PASS · exit 0

What happened

Every agent gets the same answer.

Keyword matching returns the same relevant rules for the same task.

The block names the rule.

Mneme points to the architecture decision instead of returning a vague failure.

The work can still move forward.

The agent improves retrieval without replacing the system the team chose.

Common questions

What counts as architectural drift here?

The project chose predictable keyword matching. Adding embeddings and a vector database creates a second, conflicting way to find the rules.

Why block the first change?

Later work builds on whatever lands first. Blocking the initial divergence prevents new dependencies, data paths, tests, and operating assumptions from becoming the next agent's baseline.

Is the example reproducible without an LLM?

Yes. The decision ships in examples/project_memory.json, and the commands above exercise both outcomes through mneme check.

Catch the first divergence.

Install Mneme, record the architectural decisions that matter, and check a proposed task before an agent turns it into code.

pipx install "mneme-hq>=0.5.1"
Python 3.11+ · MIT licensed