Cogmemai

CogmemAi: The Safe, Persistent Memory That Keeps Ai in Line

It remembers what matters, stops any action that breaks the rules you set before it happens, and checks what your Ai did against what you asked. For assistants, agents, robots, vehicles and code.

Every rogue-Ai story is the same story: an Ai acted, and nothing stood between the decision and the damage. CogmemAi is the part that stands there. It is a portable memory layer that gives any Ai system persistent recall across sessions, devices, users, and teams, captures knowledge autonomously even when your Ai forgets to save, enforces the rules you save before an action happens, and reviews finished work against your intent. The top published score on LongMemEval, the field's hardest long-term memory benchmark (the result). Quantum-safe encryption. Works with Claude Code, Cursor, Windsurf, Cline, Continue, and any MCP-compatible tool. Switch editors, switch models, switch machines: your knowledge stays, and so do your rules. Not just one score on a test: the most complete, and the safest, Ai memory system available.

What's New in v3

Voice Reads PDF (v3.33.1)

voice learn and voice check now read .pdf through pdf.js (loaded only when a PDF is opened): lines are rebuilt from glyph positions, hyphens at line ends are joined, and a paragraph break is a gap well above the page's line spacing or an indented first line. A scanned PDF with no text layer is reported as such rather than measured as empty. The package now requires Node 20 or newer.

Voice: Every Ai Writes Like You (v3.33.0)

npx cogmemai-mcp voice learn notes.md emails.txt paper.docx reads writing you wrote yourself, measures it on your machine (sentence rhythm and how much it varies, paragraph length, how sentences open and close, every punctuation mark per thousand words, contractions, first and second person, vocabulary level, signature words, bullets and headings), sends the measurements and short excerpts to the MSGR gateway once, and stores what comes back as rule memories: one voice_profile rule that describes the voice in checkable terms and eight to twelve voice_* rules ("NEVER use a semicolon; the writer used none in 4,200 words", "ALWAYS open about one sentence in ten with a short transition"). Rules load into every session of every Ai connected to your memory, so Claude Code, Cursor, claude.ai, a companion or a support assistant all write in your voice from the next session on, with nothing else to configure. Global by default; --project learns a brand voice for one project instead. Then cogmemai-mcp voice check draft.md (or pipe text in with -) measures a draft the same way, reports where it drifts from your writing (marks you never use, sentences twice your length, no contractions where you contract, none of your frequent words), and has the review judge it against the voice document; it passes at the threshold with no violations, so it works as a gate before anything is sent or published. The voice_check tool does the same from inside the conversation, and the instructions tell an Ai to call it before handing back any draft longer than a paragraph. voice show prints the profile, its rules and the measurements; --dry-run shows exactly what would be sent. Reads .txt, .md, .html, .docx and (from 3.33.1) .pdf. This is for writing in your own voice on your own work; it is not a detector bypass and is never tested against one.

Docs: One Answer on Keys in Local Mode (v3.32.4)

The README said in one place that local mode needs no key and in three others that it does. It does: a free key registers the install, and in local mode nothing you store leaves your machine. The environment table now says so, and the whole README reads without em dashes. No code change.

The Safe Memory That Keeps Ai in Line (v3.32.3)

No code change. The package now says plainly what Guard and Review are for: the Ai you run should never be the one in the rogue-Ai headlines. Rules you save are enforced before an action happens, whether that action is a shell command, a message, a purchase or a change, and finished work is reviewed against what you asked. See Guard, Rule Packs and Intent.

A Character Budget for Recall (v3.32.0)

Long memories are worth keeping, and expensive to load ten at a time: every tool result stays in the conversation and is read again on each later turn. recall_memories now takes an optional max_chars. With a budget, the best-ranked memories come back complete and the rest come back as 400-character snippets that keep their id, type, subject and score, each marked truncated with its real length. Nothing is hidden: call recall_memories again with the same query and expand_ids: [..] to read any of them in full, or pass max_chars: 0 for everything. To make a budget the default for your own setup, set COGMEMAI_RECALL_MAX_CHARS (for example 8000) in the server's env; a max_chars on the call always wins. Replayed over a real working day of twelve searches, a budget of 8000 cut recall output by 42 percent. Without a budget, results are exactly what they were before. Save responses are lighter too: the related-memory pointer on save_memory is now a 300-character preview with its id, and the full text is still returned whenever the similarity is high enough to suggest a merge.

Sign In Instead of Pasting a Key, and Tool Annotations (v3.31.2)

The hosted endpoint https://hifriendbot.com/mcp/ now speaks OAuth 2.1: an MCP client that supports it (claude.ai, Claude Desktop, Cursor and others) discovers the authorization server from the endpoint's 401, registers itself, sends you to a CogmemAi consent page to sign in, and gets a token with PKCE; API keys keep working exactly as before. Every tool now carries MCP annotations (title, readOnlyHint, destructiveHint, idempotentHint), so clients can label tools and decide what to confirm.

Migrate: the Cloud Migration Playbook (v3.31.0)

npx cogmemai-mcp migrate assess --target aws (or azure, gcp) reads the repository and produces the migration in one run: an inventory (languages, frameworks, data stores, cloud SDKs, infrastructure as code, containers, CI, scheduled jobs, environment variable names, external hosts, secret-looking files; names and counts only, no file contents and never a secret value leave the machine), the migration scope document written as the project's intent (what moves, what stays, NEVER and MUST invariants, phases with a definition of done each, out of scope), and MIGRATION.md with the components table, phases, a ranked risk register, cost drivers and open questions. The plan and risks are stored as memories, and the migrate pack (16 process rules: inventory first, one workload at a time, lift then modernize, rehearsed rollback, data verified by counts and checksums, bulk syncs never delete without a dry run, secrets reissued and never exported, a single writer at cutover, source read-only thirty days before decommission) and the target cloud's pack are installed. Then, after each phase, cogmemai-mcp migrate gate " " reviews the work (commits, changed files, your notes, the planned steps) against the scope and passes at coverage 80 or more with no violations; every gate result is stored so the migration has a record. Three new cloud packs ship alongside: aws (20 rules), azure (18) and gcp (17), each in that cloud's own CLI shapes: no root or primitive roles, no long-lived keys, no admin ports or databases open to the internet, no public buckets, encryption and backups and deletion protection, detective controls and audit logs never disabled, org policies and SCPs as the floor, approved regions and data residency, budgets before the first workload, tags on everything. cogmemai-mcp migrate inventory prints the inventory alone, --dry-run shows what would be sent, --no-rules skips the packs, --force replaces an existing intent. The assessment runs through the MSGR gateway on your account's daily limit.

Rule Packs: a Security Policy in One Command (v3.30.0)

npx cogmemai-mcp rules install devsecops installs 40 ready-made rules covering secrets, infrastructure as code, least privilege, network exposure, CI/CD gates, change control, containers and Kubernetes, data handling, logging and incident response, plus the rules an Ai agent on your infrastructure must obey. Each rule is an ordinary rule memory: its shell patterns stop commands before they run (terraform destroy, --acl public-read, curl | bash, kubectl delete namespace, a key pasted into export), and its plain words drive the judged guard_check and the end-of-turn review, so "copy the production dump to my laptop" is denied even though no shell pattern matches it. Add --intent to give the project a platform-and-security intent document when it has none, --global to apply the pack to every project, --dry-run to see what would be installed. Reinstalling skips rules already present, and rules show devsecops prints the whole pack before you commit to it. Rules are editable afterward like any memory. All forty rules, the intent document and a 90-second video of an agent being stopped are at hifriendbot.com/devsecops.

The Review Works Outside Git (v3.29.0)

The end-of-turn review used to need a git repository, because it read git diff. Most folders people work in from a home directory are not repositories, and neither are most non-coders' projects. v3.29.0 reads this session's edit events instead (the PostToolUse hook already records every Edit and Write), builds the same diff shape from them, checks the added text for secrets, recalls remembered landmines for the touched files, and runs the intent check. Work on several projects from one folder is judged project by project: an edit under ~/NullJury is reviewed against NullJury's intent when it has one, and the note is prefixed with that project id. Nothing changes inside a repository.

Guard and Review for Everything, Not Only Code (v3.28.0)

Until now the guard judged shell commands and the intent review judged code diffs, because those were the hooks a coding tool gave us. v3.28.0 opens both to any Ai through two tools and two REST endpoints:

• guard_check: "may I do this?" Any action (a message about to be sent, a purchase, a change, a command) is judged against the rules this person has asked their Ai to keep, plus the NEVER and MUST lines of the project intent. A literal check runs on every tier; the judged check on the paid tiers. Returns allow, ask or deny with the rule that applies, and fails open.
• review_work: "did I do what was asked?" Pass a description, output, message or transcript of what was done and it is reviewed against the intent document, or against an intent passed inline. Same plain-English result as the code review: summary, covered, uncovered, violations, coverage.

A support assistant, a companion, a robot's task planner and a coding agent now share one memory that shapes what any model does: it remembers, it enforces, it reviews. The same calls are on the SDKs (guardCheck / reviewWork, guard_check / review_work) and on REST as POST /cogmemai/guard-check and `POST /cogmemai