Is your ADR enforceable as written?
Paste one architecture decision record (ADR). The checker sorts each statement into one of three results: Mneme-ready (a rule Mneme can check), Requires modelling (a firm rule that needs a typed form first) or Guidance (advice, not a rule).
Mneme is an open-source tool that turns approved ADRs into checks that guide, warn or block AI coding agents and CI. The checker uses the same deterministic engine as Mneme's Architecture Audit. Free, no signup.
Check one ADR
Result
This ADR declares a FORBID_LITERAL rule. The Architecture Audit would report it as Protected when it finds this ADR in your repository. This checker sees only the pasted text, so it reports Mneme-ready.
The checker reads the first 40 statements. Split a long ADR into parts and check each one.
Lines not read as rules
The engine found no rule or guidance in these lines, usually status lines, context and short notes. They are listed so you can see what it skipped.
Check every decision in a repository
The Architecture Audit runs the same engine on a whole repository: ADRs, agent instruction files, architecture docs and configuration. It also shows which decisions already declare a FORBID_LITERAL rule, which it reports as Protected.
What the three results mean
- Mneme-ready
- The checker found a
FORBID_LITERALrule for the statement: exact text that must not appear in the files the rule covers. The ADR either declares the rule, or names the term in quotes so the engine can propose it. Plain prose rarely gets here. The rule is checked once the ADR is in your repository and Mneme runs there. - Requires modelling
- The statement is a firm rule, using words like "must", "never" or "do not", but the checker found no
FORBID_LITERALrule in it. Most firm rules in plain prose land here, even when they name the thing they forbid. - Guidance
- The statement reads as advice, a goal or context, using words like "should", "prefer" or "aim to". A blocking check on advice would stop changes the team meant to allow, so Mneme does not enforce it. A Mneme-format ADR whose decision declares no typed rule also comes back Guidance.
How to make a rule Mneme-ready
Mneme enforces typed rules written in an ADR, not sentences. The one type this checker reports as Mneme-ready is FORBID_LITERAL, which names exact text that must not appear in the files it covers. To add one, write the ADR in Mneme format: YAML frontmatter with id, title, status, priority and date, the decision, then a Constraints section with one line per rule, written exactly as - FORBID_LITERAL: term.
---
id: ADR-007
title: Persistent storage
status: accepted
date: "2026-10-30"
priority: foundational
scope: storage
---
## Decision
The service must not use sqlite for persistent data.
## Constraints
- FORBID_LITERAL: sqlitePaste this version and the rule comes back Mneme-ready. A literal rule blocks the term itself, not the condition around it, so "for persistent data" is not part of it. The guide How to turn an ADR into an enforceable decision shows how to limit a rule to some paths and run it with mneme check.
Why you will never see Protected here
In the Architecture Audit, Protected means the repository's own ADR declares a FORBID_LITERAL rule. This checker sees only the text you paste, not your repository, so the furthest it goes is Mneme-ready. To see which decisions in a repository are Protected, run the Architecture Audit on it.
Which ADRs it reads
Paste one ADR at a time, in Markdown, up to 64 KB. We tested the checker with three formats:
- Nygard-style ADRs, with Status, Context and Decision sections
- Markdown Architectural Decision Records (MADR), with a Decision section
- Mneme-format ADRs, with YAML frontmatter that includes
id,title,status,priorityanddate
A Mneme-format ADR is checked as one decision, the way Mneme imports it. Any other ADR is checked one statement at a time, with line numbers. Other formats may give fewer rows.
The checker never sees a file name. With the same engine version, the same text always gets the same result. The result names the version it used.
What happens to the text you paste
- Your browser sends the text over HTTPS to the Architecture Audit's server on Google Cloud Run.
- The server writes it to a temporary file, classifies it and deletes the file when the check finishes, whether the check succeeds or fails.
- Mneme saves neither the text nor the result. There is no link to come back to a result, and nobody at Mneme can look one up.
- The server's own log line for a check records its size range, status and duration, never the text. Google Cloud Run also keeps standard request logs, including time, URL, status, latency, IP address and browser user agent.
- The server calls no AI model; the classifier is deterministic.
The page sends three events to Google Analytics, without your text: check started, check finished and check failed. A started check carries its size range and a failed one an error code. A finished check carries its duration, the count per result, the count of unread lines, and whether a rule was reported as Mneme-ready instead of Protected. No statement, rule or heading from your text is sent. See Security and data handling and the privacy policy.