Integrate Mneme

Choose the interface, then wire Mneme into your stack

Mneme is an open-source tool that stores your team’s architectural decisions in the repository, such as “request handlers use the storage adapter, never the database driver”, and checks code changes against them. A check runs in a supported coding agent before its native file-write tool runs, or in CI on a pull request. Most writes made through shell commands reach disk before any check. This page groups every integration by the job it does, and gives each one a status.

What each status means

Statuses describe what exists in mneme-hq 0.10.0, the current release of Mneme’s Python package. Only the status line on each entry says what Mneme supports; some tools have a page without being supported. Text after the status names the path or limit that applies, such as “through CI”.

Shipped
Released in mneme-hq: an adapter, hook, command or reference workflow with tests in the open-source repository.
No adapter
Mneme has nothing for this tool itself. The label names the shipped path that still reaches its changes, such as CI.
Validated
Unmodified Mneme was tested working through the tool, with published evidence. No dedicated adapter.
Experimental
Code exists and some boundaries are tested, but coverage or validation is incomplete. Not for production use. An entry may rest on an unpublished experiment; when it does, its status says so.
Planned
Design or specification work only. Nothing is merged, released or supported.
Research
We are investigating whether an integration is possible. No adapter, no design commitment.
Pattern
A way to combine shipped checks, not a product. Coverage is whatever each part already has.
01

Decision interoperability

Model Context Protocol (MCP), the command-line interface (CLI) and the Python API are the three ways to reach Mneme’s decisions. They share one decision model but do different jobs, and connecting through one of them is not the same as enforcing a decision.

Shipped · runs locally, since 0.9.0

Model Context Protocol (MCP)

Six fixed tools let an MCP-capable agent search decisions, read why each was made, trace which decision replaced which, and submit a new decision for people to review. MCP cannot accept, activate or supersede a decision; people do that.
Shipped

CLI

The mneme command runs deterministic checks, audits and proposal review for local hooks, developer workflows and CI.
Shipped

Python package API

Import the installed mneme package to build custom adapters: decision storage, retrieval and context construction. The Claude Agent SDK adapter is built this way.
Shipped · CLI command

ADR Import

Bring existing architecture decision records (ADRs) into Mneme’s set of recorded decisions with one command.
02

Coding agents and harnesses

A harness is the program that runs a coding agent’s loop and tools. Where an agent offers a hook, a point where outside code can inspect an action before it runs, Mneme checks a proposed file write there. Most writes made through shell commands reach disk first: Claude Code and Codex CLI check them when the agent ends its turn, and every other agent relies on CI.

Shipped

Claude Code

A PreToolUse hook blocks Edit, Write and MultiEdit calls that violate a decision before they reach disk, and a Stop hook checks the turn’s changes at the end.
Shipped

Claude Agent SDK

Adds relevant decisions when a task starts and checks proposed file changes before they land.
Shipped

Codex CLI

Checks native apply_patch changes before they run, and audits whole files at the end of the turn to catch shell and script writes. Passed 10 of 10 validation runs against Codex CLI 0.149.1.
Shipped · Kiro CLI 3.0 only

Kiro

Native write and append tools in the Kiro CLI 3.0 (v3) engine are checked before they reach disk. The Kiro IDE is not validated.
Shipped

Google Antigravity

A pre-tool adapter checks Antigravity’s three file-writing tools before they run. Tested on IDE 2.8.1. Shell commands are not covered.
Experimental

Hermes Agent

Adds decisions to each turn and checks supported file changes before they run. Tested at the plugin dispatch layer against Hermes Agent 0.19.0; most shell writes and all process-tool writes are not checked, and there is no end-of-turn check.
Experimental · no write check released

OpenCode

The only public code is an experimental plugin that added decision summaries when OpenCode shortens a long session by summarizing it. It showed no measurable effect. No plugin that checks writes is released.

Editors and hosts without a Mneme hook

These tools have no hook where Mneme can check a write before it lands. The status names the shipped path that does reach them: another agent’s hook, a rules export, or CI.

No adapter · Claude Code hook (shipped)

VS Code

Claude Code sessions inside VS Code use the same PreToolUse hook. No extension needed.
Shipped · rules export

Cursor

mneme cursor generate writes a Cursor Rules file from your recorded decisions, resolving decisions that conflict. Cursor passes them to its model as context; the rules file blocks nothing.
No adapter · CI check (shipped)

GitHub Copilot

Copilot has no hook Mneme can use. The CI check covers its changes.
No adapter · CI check (shipped)

JetBrains IDEs

The recorded decisions and the CI check apply regardless of which IDE produced the change.
No adapter · agent hook or CI (shipped)

Warp

No Warp adapter. Checks apply when the agent Warp runs has a Mneme hook, or when CI checks the diff.
03

Agent orchestrators

Orchestrators schedule agents and handle their failures. Mneme supplies the architectural constraints that work must respect. Orchestrator middleware does not see every change: shell commands and custom execution nodes can go around it, so CI stays the backstop.

Shipped · agent middleware only

LangChain / LangGraph

LangChain agent middleware adds decisions before model calls and checks write_file and edit_file changes. Graphs that call tools through their own custom nodes bypass it.
Validated

Paperclip

Paperclip runs Claude Code in your workspace, so the Claude Code hook applies unchanged. Tested with both ways Paperclip can launch Claude Code. No adapter required.
Shipped adapter · orchestration untested

Google Antigravity

The Antigravity App launches and orchestrates teams of agents, and a parent agent can run subagents in parallel. Mneme’s adapter checks three file-writing tools and was tested in Antigravity IDE 2.8.1 only, not with subagents or the App. Shell commands are not covered.
Research · analysis only

OpenAI Symphony

Our analysis of where architectural context would enter Symphony’s work loop. No adapter exists.
Planned

Deep Agents

LangChain’s agent harness. Mneme as middleware around its filesystem tools is on the roadmap. Nothing is built, and a test against a fixed Deep Agents version would have to pass before any support claim.

Research

n8n

Whether Mneme checks could apply to AI-driven steps in n8n workflow automation. No design exists.

Research · no adapter

CrewAI

CrewAI coordinates crews of agents and step-based flows. Its agents can load tools from MCP servers, so a crew could look up recorded decisions through Mneme’s MCP server. Nothing would check what the crew writes.

Research · no adapter

Microsoft Agent Framework

Microsoft’s successor to AutoGen and Semantic Kernel, with graph-based workflows for multi-agent orchestration. Its middleware intercepts agent actions, the point where a mneme check call on a proposed write could sit. Nothing is built.

Research · no adapter

OpenAI Agents SDK

Agents hand work to other agents or call them as tools. A file-writing tool you define could run mneme check on the content before saving it. Nothing like that is built or tested.

Research · no adapter

GitHub Agent HQ

GitHub runs Copilot, Claude and Codex coding sessions side by side, and each session’s work ends in a pull request. Mneme has no hook inside these agents; the CI check on that pull request is where it applies.

Research

Custom orchestrators

A suggested pattern, not a tested one: fetch decisions over MCP, run each agent through its Mneme hook where one exists, and keep the CI check as the fallback.

04

Software factories

A software factory combines a work queue, an orchestrator, coding agents, CI and human review. Mneme does not integrate with a factory as a unit, and it is not a factory platform. It supplies the decisions the factory’s agents must respect, through the shipped checks above. For the argument, read the software factory’s missing decision layer.

Research · proposed workflow

One-issue software factory

A proposed starting workflow, not yet tested: one repository, one supported coding agent, two reviewed decisions, a CI check and a human-approved merge.

Pattern · coverage per agent

Multi-agent workflows

When several agents work on one repository, each agent with a Mneme hook checks against the same recorded decisions, and CI covers the rest. Coverage is whatever each agent has, as listed above.

05

CI and enforcement

CI is the fallback for agents and editors that have no hook. mneme check runs on the changed files of a pull request. You choose the mode: in strict mode, the default, a violation exits with code 2 and fails the job; in warn mode it is reported without failing.

Shipped · reference workflow

GitHub Actions

Run mneme check on every pull request diff with a workflow you own.
Shipped · job you copy

GitLab CI

The same check, run on merge requests.
An engineer drawing a connected workflow on a whiteboard
The same recorded decisions apply whichever tool makes the change.
06

Runtime and policy environments

Runtime environments and policy engines decide what an agent may access: files, processes, network destinations, API calls. Mneme does not enforce infrastructure policy. These pages explain how each system relates to Mneme’s architectural decisions, and what would have to be proven before any integration exists.

Experimental · private experiment, nothing released

NVIDIA OpenShell

A controlled experiment checked OpenCode’s file-write tool inside an OpenShell sandbox. The integration is proposed in a draft specification, not merged or released, and the experiment found a coverage gap.
Research

Open Policy Agent (OPA)

Whether a reviewed decision could be written by hand as a policy in Rego, OPA’s policy language, for an existing OPA deployment to enforce. No adapter or exporter exists.
Research

NVIDIA Sentry

NVIDIA’s agent security layer, which runs on a BlueField-4 network processor in the same server, isolated from the host. In October 2026 NVIDIA said it plans to release it early next year. Not the Sentry.io error tracker. No adapter exists.
Works alongside, not integrations: Perplexity Enterprise helps research the reasoning behind a decision · Microsoft Agent Forge runs autonomous workflows. Neither has a Mneme connection; their pages describe using them side by side.

Every layer reads the same file: .mneme/project_memory.json. Install with pip install "mneme-hq>=0.10.0", scaffold with mneme init, and wire the layer that fits your stack. The architectural argument: governance across heterogeneous AI coding agents. Standards alignment: MCP, AGENTS.md, NIST CAISI.