The Trust & Cost Layer for AI Agents

_{μνήμη · NEE-meh · Greek for "memory." A local-first trust boundary every AI agent crosses: it verifies before it acts, keeps your code & secrets from leaking to the model (with a signed, offline-auditable proof), remembers across sessions + vendors, and meters the tokens it saves you. The brain that bolts onto Claude Code / Cursor / Cline / Codex / Continue / ChatGPT / Gemini. Vendor-neutral. MIT. Air-gap-ready.}

🧠 Mneme is ALETHEIA — the savant of verifiable truth · memory · structure

An LLM is a brilliant generalist — and therefore prone to hallucinate and forget. Mneme is the savant beside it: it remembers across sessions and vendors, and it says UNKNOWN instead of guessing. That's the whole idea.

📖 The full story (why a savant beats a generalist · the axes · the ethos) → docs/ALETHEIA.md · 📜 Every release → CHANGELOG.md

🧠 The Sovereign Cognitive Layer — signed, vendor-neutral, byte-lossless context memory (HYDRA), self-aware wisdom gates, and a shared memory bus every AI agent (Grok / GPT / Gemini / Claude / Codex) contributes to that heals its own contradictions by proof. How to use it → docs/COGNITIVE-LAYER.md

💰 Pay-per-Token-Saved — Mneme does deterministic local work to cut what your agent sends to the model (DISTILL compresses a verbose error+diff to its causal brief; LOOPGUARD stops a thrash; NKL skips a proven dead-end), and meters the measured saving into a signed ledger — so mneme savings shows real input-tokens (and USD, at your vendor's price) you didn't spend. Falsifiable, not marketing. The model → docs/BUSINESS-MODEL.md

🏛 For the enterprise — Trust, Sovereignty, Cost

	What it answers for a CISO / CRO / CFO	In Mneme
🛡 Absolute Trust Layer	"Every agent verifies before it acts."	verify-before-act gate + cross-vendor consensus + signed audit trail
🔒 Sovereign / Air-Gapped AI	"Our code & secrets never leak to the model — with proof."	SOVEREIGN EGRESS GUARD — redacts secrets, trips on honeytoken canaries, Bloom secret-membership, signs an offline-auditable egress certificate
🌐 Standard MCP boundary	"One governed surface for all our agents."	local-first, vendor-neutral MCP server + capability passports
💰 Value-based cost	"Pay only for tokens you actually save."	the signed, measured savings ledger above

Honest by design (DIAKRISIS): every figure is measured + signed, never fabricated; USD uses your vendor's price. The pillars, the reframes (Key-Person Risk · Governance Cert · Capital Burn), and what is not claimed → docs/ENTERPRISE.md

📖 Start here

📘 Functions (EN) What Mneme does, in 5 minutes

📗 ฟังก์ชั่น (ไทย) อ่านจบใน 5 นาที

🤖 AI Agent Contract Deep install + protocol

📚 Docs index Primitives · RFCs · pricing · indispensability

👤 Author & Contact Scroll down to author bio

🚀 @mneme-ai/sdk — embed Mneme in-process

The fastest way to put Mneme inside your AI tool. A premium in-process SDK — 30-80× faster than the CLI subprocess + tagged-template verify + async-iterator events + branded types + file-lock adapter. Vendors embed Mneme silently inside Cursor / Continue / Cline / Claude Code, etc.

import { createMneme } from "@mneme-ai/sdk";
const mneme = createMneme();
const r = await mneme.verify`Mneme is a CLI tool`;   // tagged template
const id = mneme.nemesis.classify({ diff, prDescription, commitMessages });
const bench = await mneme.benchmark.vsCli();         // proves the speedup on your hardware

• 📑 SDK index (bilingual) · 🚀 Quick start EN / TH · 📘 Design EN / TH · 🔄 Migration EN / TH · 📚 Docs index

📜 Every release in full detail (v2.18 → latest): CHANGELOG.md

Install in 60 seconds — you don't type the commands

Just one sentence to any AI agent you already use:

"Install Mneme from https://github.com/patsa2561-art/mneme-ai per the AI agent contract."

The agent reads docs/AI_AGENT_CONTRACT.md — 775 lines of deterministic steps — and runs everything on your behalf: env detect → npm install -g mneme-ai → mneme init → mneme mcp --install (auto-configures itself as your MCP client) → verify after restart → security auto-arms. You speak natural language; the AI handles the tooling. That's the MANDATE: "The user will NEVER type a CLI command."

🛠 Shell-native agents — they install Mneme for you

Drop the sentence above into any of these. They have shell access + can read the contract.

🌐 Browser-only AIs — one-click polygraph (no shell needed)

For chat surfaces without shell access — ChatGPT · Claude.ai · Gemini · Copilot · DeepSeek · Qwen · Grok web — Mneme ships a Tampermonkey userscript that lights up live truth-dots inline as the AI answers.

Tell ANY agent: "set up Mneme browser polygraph for me" — it runs mneme polygraph autosetup and walks you through the 2 unavoidable browser-side clicks (install Tampermonkey once + click "Install" in the script prompt).

npm install -g mneme-ai
mneme init                  # one-time per repo
mneme mcp --install         # auto-detects Claude Code / Cursor / Codex / Continue / Cline / Gemini CLI / Grok CLI

Restart your AI tool. First MCP call: mneme.welcome → loads install handoff + recent changes.

For browser polygraph manually: mneme polygraph autosetup.

What Mneme does

Mneme is 15 primitives every AI agent can call. Each has discrete pinned tests, HMAC-chained ledgers, and offline verification. Each row below is a story — what it is, who it's for, why it exists:

The 30-second pitch

Other AI tools are goldfish. They forget every session, hallucinate files that don't exist, repeat 2024's buried bugs, burn tokens re-pasting context, and can't follow you to another AI.

Mneme bolts an elephant brain on top. Cites every commit by SHA. Refuses to relay claims it can't verify. Carries memory across sessions and vendors. And — uniquely — runs the same claim through multiple AI vendors with Anti-Eval-Awareness rewriting so you catch the vendor that "performs differently when it knows it's being tested."

What sets Mneme apart

Every claim below is measurable + has a probe + can be reproduced from a fresh clone:

• 🧬 NEMESIS — world's first Anti-Identity-Lie Engine for AI agents (v2.46.0) — composes academic vendor-fingerprinting (arxiv 2601.17406 — 97.2% F1 across 33,580 PRs) with Mneme's HMAC chain and EU AI Act Article 50 (enforceable 2 Aug 2026). 5 organs: (1) Fingerprinter — extracts 41 behavioral features from any diff/PR/commits + env-var scan (CLAUDECODE / CURSOR_AGENT / DEVIN_SESSION / ...); (2) Lie Detector — compares claimed vendor vs detected and emits HMAC-signed CONFIRMED / DISPUTED / IMPOSSIBLE verdict; (3) Article 50 Auto-Stamper — appends machine-readable disclosure block to every commit (auto-installed git pre-commit hook + zero-width-stego watermark fallback); (4) Model Drift Timeline — flags when a vendor's fingerprint shifts ≥3σ ("your Cursor changed personality on 2026-04-15"); (5) Replay Attack Detector — same-prompt-same-vendor variance over 8 discriminator features ≥ 0.6 → stealth-upgrade / stealth-downgrade flag. Verified by claim.nemesis.world_first — drift trips TRUTH GATE.
• 👁×11 ARGUS multimodal search — 11 eyes (5 surface lex/phon/shape + 5 truth HMAC-chain/honest-mirror/number-paraphrase/homoglyph/embedding + 2 multimodal image/code) with softmax-rebalancing Guardian (failed eyes auto-redistribute weight, never a blind spot) + bloom pre-filter (cuts 1000-candidate corpora to ~50 in <5ms) + PHANTOM EYE lazy eval (expensive eyes only fire when cheap eyes leave verdict ambiguous, ≥3× wall-time reduction) + HYDRA autospawn (every accepted antivirus strain becomes a new search signal) + HMAC-signed audit frame. Verified by claim.argus11.world_first_multimodal — drift trips TRUTH GATE.
• AEAE (Anti-Eval-Awareness Engine) — Anthropic published evidence Opus 4.6 detects benchmarks + changes behavior. Mneme rewrites every claim into 5 variants (verbatim / paraphrase / decoy-embedded / casual-question) and flags vendors that flip stance across variants.
• HMAC-chained everything — every verdict, every gauntlet card, every truth matrix, every consensus result is HMAC-chained and offline-verifiable. Tamper-evident across machines.
• Bug Immunity Protocol — every reproducible audit bug becomes ONE pinned test row that fails forever if the bug returns. Each row encodes finding-ID + broken-contract + fix-source-file + assertion.
• Living Soul Codegraph — code-graph with touchedBy (which AI made each edge) + drift sentinel + hallucination vaccine. A map that knows WHO touched it WHEN.
• MCP Hardening — 108-vector fuzzer + 12-probe scorecard ship as callable npm primitives. Self-grade currently 100/100.
• Self-honest marketing — every README claim binds to a probe (mneme truth_gate run → 17/17 = 100/100). If marketing copy drifts ahead of implementation, the gate refutes it — same release pipeline that signs the build refuses to ship.

What's new (recent releases)

• v2.104.0 🧠 THE COGNITIVE CORTEX — a Sovereign Memory Bus every AI vendor shares, that HEALS its own contradictions by proof. A local, vendor-neutral, Ed25519-signed, drift-guarded shared memory that Grok / GPT / Gemini / Claude / Codex all contribute to and recall from. Mneme is the logic gatekeeper: a contribution that contradicts established memory is QUARANTINED, never silently overwritten — the mesh can't be poisoned. The magical power: reconciliation by PROOF — when two agents disagree, the cortex consults the truth kernel; if one claim is verifiably FALSE the other wins (signed), and if neither can be proven false it stays quarantined with a signed belief-diff (never auto-decides an opinion). mneme cortex · MCP mneme.cortex.{contribute,recall,handoff,reconcile,verify}. Honest: a safe cross-vendor protocol, not a kernel hack or process injection. Adversarially reviewed (6 real bugs found + fixed + pinned). (CHANGELOG)
• v2.103.0 🧠 Two Wisdom Gates that empower every agent — Cognitive Gate + Branch Oracle — Cognitive Gate (NEMESIS × HYDRA): a self-aware, signed second opinion on whether a diff matches an author's coding style — and crucially it returns UNKNOWN and refuses to flag when it can't actually separate styles (prove-or-unknown; never auto-rejects). The honest core of "cognitive entanglement" without the quantum-mysticism. Branch Oracle: a signed real-signal snapshot of every branch (merge-conflict overlap / decay / divergence → healthy/caution/risky) — the "multi-timeline" idea made honest (present-tense signals, not fortune-telling). Both gather their own git facts, are NOTARY-self-attesting (any vendor verifies offline), and are 100% total (never throw). mneme cognitive-gate · mneme branch-oracle · MCP mneme.cognitive.judge / mneme.branch.analyze. (CHANGELOG)
• v2.102.0 💤 HYDRA Epigenetic Dormancy — sleep state + JIT revival — the image's "Epigenetic Sleep State" + "Demethylation", made real (and honest — it's deterministic tiered memory, not biology and not fortune-telling). Cold codebook entries are methylated (moved out of the active working set into a cold signed store, shrinking the active footprint ~50-70% at scale) and demethylate byte-exact on demand — a full revive reconstructs the original codebook with an identical canonical hash, Ed25519-signed. Lossless-revival proof, never lossy. mneme hydra sleep. (CHANGELOG)
• v2.101.0 🔌 HYDRA → MCP: self-attesting tool results — any AI agent now calls the whole HYDRA stack straight through MCP (mneme.hydra.forge/.gauntlet/.guard/.chain/.replay/.verify). The crazy-but-accurate gem: every result is wrapped with a NOTARY (Ed25519) signature over the SHA-256 of its own data, so the calling model — Claude, GPT, Gemini, anything — can verify offline that the tool didn't lie or get tampered. Output you can check, not output you must believe. Proven end-to-end through the real MCP JSON-RPC server (forge → score 100 → sig valid → hash matches; tamper the data → caught). (CHANGELOG)
• v2.100.0 ⏳ HYDRA Guard × Chain — temporal guarded replay — the two gems fuse: replay the codebook at any past step and staleness is derived from the chain's own history (atrophy). An entry added long ago and never touched expands only to a signed abstract on replay — a time-traveling agent gets the shape of old knowledge, not rotten detail. Deterministic + proven-old-only (unknown ⇒ fresh). mneme hydra replay <index> --guard. End-to-end proven (redact cold, keep fresh byte-exact). (CHANGELOG)
• v2.99.0 🪝 HYDRA Chain → Git — every commit auto-appends a signed HYDRA context delta anchored to its commit sha (forge the anchor → caught). A fail-open, non-blocking post-commit hook (mneme hydra install-hook) builds a portable, offline-verifiable record of what Mneme knew at each commit — complements git, doesn't replace it. Proven end-to-end: a real-git-repo loop test (20 commits + hook + tamper + idempotency + corrupt-recovery) — 93/93 green. (CHANGELOG)
• v2.98.0 ⛓ HYDRA Provenance Chain — memory with a cryptographic, replayable, byte-exact history. Each codebook evolution is a signed delta chained to the last; the chain replays to any past step byte-for-byte, verifies offline (Ed25519 + prev→result links) with the public key alone, and is tamper-evident (edit any delta → localized break). The deepest fusion — NOTARY × HYDRA, at the root. mneme hydra chain. (CHANGELOG)
• v2.97.0 🛡 HYDRA Guard — Time-To-Trust — the fusion gem: HYDRA × the knowledge-atrophy clock × NOTARY. Guarded expansion is byte-lossless for trusted content but provably redacts stale memory to a signed abstract (sha256 + byte-count, never the raw text) — so an AI cannot hallucinate from expired knowledge, yet can still verify the redacted region's identity and request re-hydration. Four measurable invariants (fresh-lossless ∧ redaction-sound ∧ fresh-preserved ∧ deterministic) + every guard function is total (never throws; fail-closed). mneme hydra guard. (CHANGELOG)
• v2.96.0 💎 HYDRA — the signed, provably-lossless, vendor-neutral context codebook Mneme forges from its own corpus. A live engine mines it, then refuses to ship unless compress→expand is byte-identical (SHA-256 proof — not a similarity score), collision-free, and Ed25519-signed (verify offline). Honest: the win is the cut (signed × lossless × portable on the NOTARY spine — a composition prior-art found unfilled), not the compression ratio. (CHANGELOG)
• v2.95.0 🧼 AUP-gap closure — Mneme's own manifest stops tripping Anthropic's cyber-content classifier (33 high triggers → 0, measured), via a case-preserving lexicon + the manifest doctor auditor. (CHANGELOG)
• v2.94.0 🤫 ETHOS §XI + whisper-not-nag — character proven by subtraction; the upgrade notice is version-deduped under severity tiers (security always · feature once-per-new-version · cosmetic quiet).
• v2.92.0 💎 DIAKRISIS — the second axis: discern genuine vs merely-good-looking (Reject-or-Unknown · structural lustre · Padgett anti-conservatism guard).
• v2.91.0 💎 ANAMNESIS — compute once, recollect forever: a cross-vendor signed proof cache; the first AI pays inference, every AI after pays ~0 (the energy layer of truth).
• v2.88–2.90 🧠 ALETHEIA — the savant identity (Prove-or-Unknown) + the truth diamonds (Axiom Lattice · Symbiosis · Idle Compounding · Public Gauntlet · Truth Mesh).
• v2.86–2.87 🔨 HEPHAESTUS — the command Toll Booth: pre-flight + a real cross-vendor tribunal + GEPHYRA MCP-proxy.
• v2.83–2.85 🌉 GEPHYRA — the Toll Booth of Truth, graduated to the deployable @mneme-ai/gephyra package.
• v2.79–2.82 🏛 TRUST FABRIC — NOTARY (Ed25519 offline-verifiable proof) + the 10-diamond fabric on its spine.
• v2.74.0 ⏳ CHRONOS — temporal self-consistency as a ground-truth-free honesty signal. Every AI answer → HMAC-timestamp + semantic embed → append-only ledger; same-question revisits classify as COHERENT / LEGITIMATE_UPDATE (changed with a cited source) / SELF_REPORTED / SILENT_DRIFT 🚩 (changed with nothing backing it). Per-agent temporal-honesty score = Wilson-LB on consistent revisits × exponential silent-drift penalty. The xAI/Grok weapon: prove "I changed because the world changed, not because I'm fickle." 4 CLI verbs + 4 MCP tools + 48 pinned tests. (CHANGELOG)
• v2.36.0 📜 HONEST RECEIPT + ACGV Layer 0d — closes 4 audit-card bugs (recursive self-verify on historical version / multi-install ambiguity / wiring_proof CLI missing / latency-claim drift). New ACGV Layer 0d emits HISTORICAL_CLAIM caveat instead of refuting past-version claims against current state. HONEST RECEIPT module signs every CLI invocation with install path + version + code path + latency. New CLIs: mneme honest, mneme doctor_install, mneme wiring_proof. 22 new pinned tests. (CHANGELOG)
• v2.35.0 🔌 WIRING-PROOF PROTOCOL — closes the WIRING LAG bug class forever. v2.34.0 fixes lived in core but were silently overridden at the CLI surface (forensic merge overwrote SELF-PARADOX headlines, pulse counter diverged from CLI). v2.35.0 wires CORE→CLI for 5 visible regressions + ships WIRING-PROOF TESTS that spawn the actual mneme verify subprocess and assert user-visible stdout. 9 new pinned tests. (CHANGELOG)
• v2.34.0 🛡 BUG IMMUNITY PROTOCOL v2 — 4 audit-card persists + 3 session-found bugs closed at root: new ACGV Layer 0b (self-reference + liar-paradox detector — R1+NEW2) + Layer 0c (fake commit hash oracle via git cat-file -e — NEW3) + INPUT_TRUNCATED visible headline (R3) + pulse↔CLI inbox single-source-of-truth (NEW1). 14 new pinned regression tests. (CHANGELOG)
• v2.33.0 🛐 CITIZEN COURT + 🕸 MNEMNET + 📐 PULSECOST + 🪤 COERCION AUDIT — paper-grade primitives covering 4 of the 5 academic research directions in one shipped release. The marquee: user-judged Honesty Score Cards for every vendor, with optional DP-federated public roll-up. (CITIZEN COURT · MNEMNET · PULSECOST · COERCION)
• v2.32.0 🌀 FLYWHEEL — self-reflective release organ. 5-stage pipeline over signals from every audit primitive. Closes 4 historic weaknesses (tool sprawl + solo-dev asymmetry + wiring lag + marketing drift) as ONE primitive. RECIPROCITY layer turns vendor responses to bulletins into auto-applied trust deltas. (docs)
• v2.31.0 🪄 REWIND + 🧬 HGP — Time-Capsule Regression Replay (your repo becomes a personal SWE-bench vendors can't pre-train on) + Hallucination Genome Project (CVE-style HGP-YYYY-NNNNN IDs for every refuted claim). Both compose with CONCLAVE Aletheia weights. (REWIND · HGP)
• v2.30.0 💎 HONEST MIRROR — Tests vendors on YOUR OWN past git commits. Vendors can't tell it's an eval. Closes the truth-tunes-trust loop with CONCLAVE. (docs)
• v2.29.1 📘 Docs refresh + agent manifest sync (22 commands added so AI agents discover every new family).
• v2.29.0 🏛 MNEME CONCLAVE — Cross-vendor Byzantine consensus + AEAE. Closes Q1 of the 2026 AI-eval research gap. (docs)
• v2.28.x 🛡 BUG IMMUNITY PROTOCOL + HTTP bridge hardening (15 vectors lifted to 9-10★). (CHANGELOG)
• v2.27.0 🟢 MARKETING TRUTH GATE. (docs)
• v2.26.x 🏆 PEAK PERFORMANCE GAUNTLET 100/100 (avg 10.0★ across 12 findings).
• v2.25.0 🧬 LIVING SOUL CODEGRAPH ships 10 differentiators vs CodeGraph competitor.
• v2.24.0 🎯 MCP FUZZER 108 attack vectors.
• v2.23.x ACGV hyperbole detector + Layer -1 input guard + MCP-CANDOR/0.1 spec.

Full changelog: CHANGELOG.md · Long-form README: docs/README_FULL.md

For AI agents reading this

You can self-discover everything. docs/AI_AGENT_CONTRACT.md (775 lines) is the deterministic install + operation contract: env detect → install → MCP auto-configure → verify → security auto-arm → upgrade → discovery → tool naming → user-intent dispatch table → companion modules. Read it once on first contact; it tells you every command + when to call it.

After install, your CLAUDE.md / AGENTS.md / GEMINI.md gets an auto-injected ## Mneme command manifest block (220+ entries) with every shipped primitive + "when to call". Re-read on every session start — new commands ship there within minutes of an upgrade.

Run these in order on every fresh session:

1. mneme.welcome — install handoff + what changed since last session
2. mneme.capabilities (skinny mode is default; ~3KB) — tool catalog
3. Before relaying any factual claim with specific entities: mneme.truth.check { claim } OR mneme verify "..."
4. For high-stakes claims: mneme.conclave.run with 3+ vendors for cross-vendor consensus

MANDATE from the contract (non-negotiable): "The user will NEVER type a CLI command. They speak natural language. You — the AI agent — execute every command on their behalf." If you have shell access, USE IT. If you're chat-only, tell the user once then continue with what you CAN do.

The auto-injected ## Mneme command manifest block in CLAUDE.md lists every command + when to call it. Re-read on every session start — new commands ship there within minutes of a Mneme upgrade.

Deep contract: docs/AI_AGENT_CONTRACT.md.

Compose with

• Claude Code · Cursor · Cline · Codex · Continue — native MCP
• ChatGPT · Claude.ai · Gemini · Copilot · DeepSeek · Qwen — browser polygraph (mneme polygraph autosetup)
• Any HTTP-aware tool — mneme bridge (default :17741)
• Cross-machine — Merkle-root sync + HMAC-chain attestation

👤 Author & Contact

The bottleneck of every frontier-AI deployment is TRUST. In production AI — autonomous systems, medical AI, financial AI compliance, regulated industries — a hallucinated commit hash, a paradox-class category error, or a benchmark-aware behavior shift isn't a chat-glitch; it's a deployment risk. Mneme is a local-first, vendor-neutral truth layer that (a) refuses to relay unverified claims, (b) detects when a model's stance shifts under eval-shaped vs natural prompts (AEAE), and (c) emits HMAC-chained receipts of every audit so an operator can re-verify offline weeks later. Built solo, MIT, production-grade, 329+ pinned tests, dual-100 GAUNTLET + TRUTH GATE. Open to collaboration / consulting / full-time on truth-infrastructure for production AI.

🤝 Support · Partnership · Collaboration

Interested in supporting Mneme, partnering on truth-infrastructure, or exploring something together?
Reach me on any of the channels below — I read every one.

สนใจ support / ร่วมเป็น partner / collaborate? ทักได้ทุก channel ด้านล่างเลยครับ — อ่านทุกข้อความ

_{Whether you're a vendor wanting to embed Mneme inside your product · an enterprise needing safety-critical AI guardrails · a researcher building on the corpus · a regulator exploring AI-disclosure tooling · or just someone with a sharp question — the inbox is open.}

---

💬 Channels

Channel	Handle
	[email protected]
	@patsa2561-art (open an issue, drop a DM via profile)
	@mneme_npm
	pat195 (username shinnapat)
	+66 93 945 5645

_{Open to: collaboration on truth-infrastructure / AI safety / cross-vendor consensus protocols · consulting for safety-critical AI deployments · vendor partnerships (embed Mneme inside Cursor / Continue / Cline / Claude Code / Grok-CLI / etc) · enterprise compliance for EU AI Act Article 50 · full-time roles where the bottleneck is trust, not capability.}

🔗 Links

• 📦 npm: mneme-ai
• 💻 GitHub: patsa2561-art/mneme-ai
• 📘 Functions (EN): docs/FUNCTIONS-EN.md
• 📗 ฟังก์ชั่น (ไทย): docs/FUNCTIONS-TH.md
• 🤖 AI Agent Contract: docs/AI_AGENT_CONTRACT.md
• 📜 CHANGELOG: CHANGELOG.md
• 📃 License: MIT