Mneme HQ enforces architectural decisions at the generation stage — wherever that generation happens. These integrations connect Mneme to the editors, agents, and pipelines in your existing stack.
Integrations

# 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

Native integration

### 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.

Plugin hooks

### Governing OpenCode Workflows

OpenCode runs the agent across terminal, IDE, and desktop. Mneme registers on its plugin hooks — advisory while editing, blocking before commit — so the same decisions hold on every surface.

Rules export

### Mneme HQ + Cursor

Keep architectural decisions in Mneme's structured corpus. Export to Cursor Rules for every session — one authoritative source, two surfaces.

CI enforcement

### 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.

Corpus import

### Import Existing ADRs

Bring your existing ADR corpus into Mneme's enforcement pipeline. Import, parse, and activate decisions in one command — no manual rewriting.

Corpus + CI gate

### 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.

Native integration

### 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.

CI enforcement

### 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.

Corpus + CI gate

### 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.

Works alongside

### Warp AI Terminal Governance

Warp orchestrates Agent Mode and autonomous execution. Mneme HQ preserves the architectural invariants underneath those loops — enforced at the file-write boundary regardless of which agent Warp spawns.

Planned

### 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.

Works alongside

### 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.

Agent infrastructure

### Architectural Governance for Microsoft Agent Forge

Agent Forge provides the execution substrate for enterprise autonomous workflows. Mneme adds deterministic architectural governance and verification before autonomous changes propagate downstream.

Agent-first IDE

### Architectural Governance for Google Antigravity

Antigravity lets coding agents plan, execute, and verify work across editor, terminal, and browser. Mneme adds deterministic architectural governance so autonomous agent workflows stay aligned with ADRs and repository invariants.

## 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-hq`, 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.