Governance for the tools you already use
Mneme HQ fits into AI editors, CI pipelines, and agent runtimes — enforcing architectural decisions at every stage of the generation workflow.
Where Mneme fits in your AI coding stack
Mneme HQ is the governance layer above your AI coding stack, not a replacement for the tools in it. Each integration connects Mneme's enforcement engine to a different point in your development workflow.
AI coding stack integrations
Governing Claude Code Workflows
Hook-level enforcement for every Edit, Write, and MultiEdit Claude Code attempts. Violations block before they reach disk — no PR required.
Mneme HQ + Cursor
Keep architectural decisions in Mneme's structured corpus. Export to Cursor Rules for every session — one authoritative source, two surfaces.
Architectural Governance in GitHub Actions
Run Mneme's enforcement checks against every PR diff. Block merges that violate architectural decisions — a second enforcement layer after generation.
Import Existing ADRs
Bring your existing ADR corpus into Mneme's enforcement pipeline. Import, parse, and activate decisions in one command — no manual rewriting.
Mneme HQ + GitHub Copilot
Copilot generates in VS Code and JetBrains. Mneme HQ is the constraint layer above it — one structured decision corpus, enforced at the CI gate and exportable as Cursor Rules.
Mneme HQ + VS Code
VS Code is the host for Claude Code and Copilot. Mneme's PreToolUse hook governs every Edit, Write, and MultiEdit a Claude Code session attempts — no extension required.
Architectural Governance in GitLab CI
Run Mneme's enforcement checks against every merge request diff. Block pipelines that violate architectural decisions — the same CI gate pattern as GitHub Actions, native to GitLab.
Mneme HQ + JetBrains IDEs
JetBrains AI Assistant runs across IntelliJ, PyCharm, WebStorm, and the rest of the family. Mneme HQ's decision corpus is the constraint layer those sessions read — enforced via mneme check in CI regardless of the IDE.
n8n
Governance checks for AI-driven workflows and automation pipelines. Constraint and policy validation for autonomous workflow steps that invoke LLMs.
Research & analysis assistants
These tools help engineering teams understand why a decision is right. Mneme preserves what must remain true after the decision is made. They sit at different stages of the decision cycle and work alongside each other.
Perplexity Enterprise
Perplexity gives teams cited, up-to-date answers about technology choices. Mneme takes those choices and makes them enforceable — closing the gap between research rationale and governance constraint.
How the integrations fit together
Mneme is the same decision corpus across every integration. The Claude Code hook intercepts Edit, Write, and MultiEdit at the editor layer; the Cursor rules export gives that same corpus to Cursor sessions; the GitHub Actions gate runs mneme check against every PR diff in CI. One project_memory.json, three enforcement points, no per-tool duplication.
The reason this matters in practice: most engineering orgs are no longer one-tool shops. An engineer pairs with Claude Code in the terminal, opens Cursor for a frontend touchup, and a Claude Agent SDK bot in CI opens PRs while they sleep. Without a tool-agnostic governance layer, every additional tool is a new place for architectural decisions to drift. With one, every additional tool is net additive: more capability, same enforcement.
For the architectural argument behind this design, see architectural governance across heterogeneous AI coding agents. For how Mneme aligns with the emerging cross-tool standards (NIST CAISI, MCP, AGENTS.md), see the standards landscape.
Practical setup follows the same pattern across every integration: install with pip install mneme, scaffold the decision corpus with mneme init, and wire the integration's adapter (PreToolUse hook for Claude Code, rules export for Cursor, GitHub Action for CI). Each integration page links its own concrete steps; the corpus itself is the same file.
If your team is evaluating which integration to start with, the typical sequence is: Claude Code first (interactive enforcement gives the fastest feedback loop), then GitHub Actions in warn mode (catches what slips through), then strict mode in CI on the most architecturally-stable repos. Cursor sits alongside Claude Code for engineers who prefer that editor — the underlying corpus is identical.