Mneme HQ is designed to operate across the AI coding ecosystem — frontier and open-weight models, third-party coding agents, agent frameworks, and the environments engineering teams already run them in. The decision corpus is the constant; everything upstream of it can change.
Works With

# Governance across AI coding models and agent frameworks

Mneme works across frontier, open-weight, and self-hosted AI coding systems by enforcing architectural decisions before generation.

This page describes compatibility, not partnership. Where a native, documented integration exists, it is linked through to /integrations/. Everywhere else, Mneme is designed to operate alongside the tool at the file-write or context-injection seam — harnesses coordinate execution, Mneme enforces architectural intent, and they run side by side. The argument in full: Harness Engineering Still Needs Governance.

## Model providers

Mneme HQ is model-agnostic. Governance operates at the seam where the agent reads context and writes to disk, so it does not care which model produced the tokens.

Frontier · compatible with

### OpenAI

GPT-class models via the OpenAI API and OpenAI-compatible endpoints.

Frontier · compatible with

### Anthropic

Claude models via the Anthropic API and Claude Code's native runtime.

Frontier · designed to support

### Google Gemini

Gemini models accessed via Google AI APIs and compatible runtimes.

Open weight · works alongside

### GLM

GLM-class models served through hosted or self-hosted inference.

Open weight · compatible with

### Qwen

Qwen models via OpenAI-compatible inference endpoints.

Open weight · designed to support

### DeepSeek

DeepSeek-class models in hosted and on-prem deployments.

Open weight · works across

### Mistral

Mistral-family models, including instruct and code-tuned variants.

Open weight · compatible with

### Llama

Llama-class models served via vLLM, Ollama, Together, Groq, and similar runtimes.

Open weight · designed to support

### Nous Hermes

Nous Research's open-weight Hermes models accessed via hosted or self-hosted inference. Mneme is model-agnostic; the decision corpus is injected at the runtime seam regardless of which Hermes variant the agent is running.

Mneme is model-agnostic and designed for heterogeneous agent environments. Decision context is injected at the runtime seam, not baked into a model-specific format. Swapping a frontier model for an open-weight one (or vice versa) does not require re-encoding the corpus.

## Coding agent ecosystem

Mneme is built to operate alongside the coding agents engineering teams already use. The governance layer can supply decision context to any agent that exposes hooks, file-system access, or a system-prompt seam — and can validate outputs at the CI boundary.

Native integration

### Claude Code

Hook-level enforcement via SessionStart, PreToolUse, and PostToolUse. One of the three documented native integrations.

Native integration

### Cursor

Rules export from the Mneme decision corpus into Cursor's rules system. One of the three documented native integrations.

IDE agent · designed to support

### GitHub Copilot

Designed to support governance alongside Copilot in the editor and in Copilot-driven CI workflows.

Open-source agent · works across

### OpenHands · OpenDevin

Works across open-source autonomous coding agents that expose tool-use boundaries.

CLI agent · compatible with

### Aider

Compatible with Aider's repo-aware editing flow; decisions surfaced through context injection.

IDE agent · designed to support

### Cline

Designed to support Cline's autonomous coding loops in VS Code-compatible environments.

IDE agent · works alongside

### Roo Code

Works alongside Roo Code's agent surface for governance across its editing and execution paths.

CLI agent · designed to support

### Grok Build CLI

xAI's CLI coding agent. No documented native integration today; designed to be governable at the file-write boundary like other CLI agents — the architectural corpus stays enforceable at the CI gate regardless of which agent produced the diff.

Enterprise coding agent stack · works alongside

### Mistral Vibe

Mistral Vibe brings terminal-native agents, IDE extensions, async workflows, codebase-aware context, and custom model training into enterprise coding workflows. Mneme sits beside that execution layer by turning architectural decisions into enforceable constraints before agent-generated changes become drift.

Autonomous coding agent · works alongside

### Devin

Devin executes — plans, edits, runs commands, opens PRs autonomously across repos. Mneme preserves architectural intent across that execution: ADR-derived constraints, deterministic retrieval, hook and CI enforcement that holds across whichever agent ran.

Claude ecosystem · works alongside

### Claude Marketplace

The Claude Marketplace surfaces partner products across generation, memory, orchestration, and review. Mneme operates one layer above as the architectural governance layer that runs before generation and at every execution boundary.

Agent-first IDE · works alongside

### Google Antigravity

Antigravity coordinates autonomous coding agents across editor, terminal, and browser. Mneme works alongside agent-first development environments by providing repo-native architectural governance, ADR retrieval, and deterministic checks.

## Agent frameworks

For teams building custom agents, Mneme is designed to plug into common orchestration frameworks as a context source and a validation step. The governance corpus is the constant; the framework choice is operational.

Orchestration · compatible with

### LangGraph

Compatible as a context provider node and a post-step validator in LangGraph-defined flows.

Multi-agent · designed to support

### AutoGen

Designed to support AutoGen agent groups by feeding shared decision context across roles.

Multi-agent · works alongside

### CrewAI

Works alongside CrewAI crews as a governance layer that all crew members defer to.

Orchestration · compatible with

### Semantic Kernel

Compatible with Semantic Kernel pipelines as a plugin-level constraint and context source.

Orchestration · designed to support

### OpenAI Agents SDK

Designed to support Agents SDK builds via tool-call interception and structured guardrails.

## Workspace execution surfaces

Workspace platforms are becoming agent execution environments — places where agents don’t just retrieve context but read, write, search, and trigger workflows. As the boundary between knowledge and execution collapses, governance extends beyond code generation into these operational surfaces.

Workspace platform · on the roadmap

### Notion

Notion is evolving into an agent execution environment — not just documentation, but a surface where agents read, write, search, and trigger workflows. Governance for ADR ingestion, decision corpus import, and invariant preservation across workspace mutations is on the roadmap.

The boundary between knowledge and execution is collapsing. As workspace platforms become agent execution environments, architectural governance expands beyond code generation into the operational surfaces where agents mutate state. Invariant preservation does not stop at the file-write boundary — it extends to every surface where an agent can change the system.

## Execution & deployment environments

Mneme runs where engineering teams already work — the laptop, the AI-native terminal, the CI runner, the self-hosted platform — without requiring a hosted control plane.

Local

### Local developer workflows

Runs alongside the developer's editor and CLI agents; governance enforced before the file is written.

AI-native terminal · works alongside

### Warp

Works alongside Warp’s AI-native terminal and autonomous execution workflows. Warp accelerates how teams run agents and orchestrate tasks; Mneme preserves the architectural invariants underneath those execution loops.

Pipeline · compatible with

### CI/CD pipelines

Compatible with standard CI runners as a pre-merge governance check on AI-generated diffs.

Native integration

### GitHub Actions

`mneme check` on every PR diff. One of the three documented native integrations.

Self-hosted · designed to support

### Self-hosted environments

Designed to support air-gapped and on-prem deployments with self-hosted inference.

Enterprise · works alongside

### Enterprise development platforms

Can operate alongside enterprise IDE platforms and internal developer platforms (IDPs).

## The governance layer

However the upstream choices are made — whichever model, whichever agent, whichever framework — the governance layer is the constant the codebase is protected by.

Architecture · positioning
Upstream
Models & agents
OpenAI · Anthropic · Gemini
Cursor · Claude Code · Copilot
LangGraph · AutoGen · CrewAI
→
Governance layer
Mneme HQ
decision corpus · precedence engine
pre-generation enforcement
→
Downstream
Codebase & CI
repos · PRs · pipelines
review · merge gates

Models change. Agents change. Frameworks change. The decision corpus is what survives the swap.

Core positioning
Models will change.
Architectural governance must persist.

Mneme HQ is built to be the layer that does not have to be re-chosen every time a frontier model, coding agent, or framework gets replaced.

## Get started

Source GitHub → MIT-licensed. Read the implementation, file an issue, contribute. See it run Demo → Worked examples of pre-generation governance on real repos. Methodology Benchmark results → How governance adherence is measured and reported.

Compatibility statements above describe what Mneme HQ is designed to support and operate alongside. They do not imply official partnerships or vendor-blessed integrations. Where a native, documented integration exists, it is linked to from /integrations/.

Why this list is broad on purpose: see Model-Independent Governance — the design property that lets Mneme produce the same verdict at every enforcement surface regardless of which model or harness generated the work — and the worldview essay Models Are Temporary. Architectural Intent Is Not.