Works alongside · Claude Marketplace

# Architectural Governance for Claude-Powered Development Workflows

Mneme works alongside Claude Code, the partner products in the Claude Marketplace, CI systems, and AI-assisted developer tooling — to preserve architectural decisions across autonomous development workflows. The marketplace covers generation, memory, orchestration, and review. Mneme covers the governance layer that runs before any of them.

GitHub Claude Code integration

## The emerging Claude-powered ecosystem

The Claude Marketplace surfaces partner products across four operational layers of AI-assisted software development:

- Coding environments — sandboxed runtimes and IDE agents (e.g. bolt.new)
- Memory and context — repository indexing and retrieval (e.g. Augment Code)
- Orchestration — knowledge workflows and multi-agent coordination (e.g. Hebbia, Legora)
- Review and verification — PR-stage and post-generation checks (e.g. CodeRabbit)

Mneme occupies a different layer: architectural governance. It runs before the agent generates and at every execution boundary — not after the diff lands.

Coding environments
bolt.new, IDE agents, sandboxed runtimes
Memory / context
Augment Code, codebase indexes, retrieval pipelines
Orchestration
Hebbia, Legora, multi-agent workflows
Architectural governance
Mneme — deterministic ADR-derived constraints, invariant preservation, verification contracts
Review / verification
CodeRabbit, post-generation checks, observability

## Governance before review

Most AI-assisted tooling, including review-focused products in the marketplace, operates after the agent has acted. Mneme operates before.

#### Post-generation

- PR-stage review
- Runtime evaluation
- Drift detection
- Logs and traces
- Observability dashboards

#### Pre-generation

- ADR-derived constraints
- Architectural invariants
- Verification contracts
- Governance packets per task
- Hook-level enforcement

Review scales review. It does not preserve architectural intent upstream. Mneme is the layer that runs before the agent — so the queue does not have to catch architectural drift after it lands.

## Works alongside Claude workflows

Concrete adjacency points where Mneme runs alongside Claude-powered tooling and marketplace partners:

Native integration

### Claude Code hooks

SessionStart, PreToolUse, and PostToolUse hooks for hook-level enforcement during Claude Code sessions.

CI gate

### GitHub Actions

Deterministic governance verdicts on every PR — same constraints whether the diff came from Claude Code, Cursor, Copilot, or a marketplace partner.

Agent SDK

### Claude Agent SDK

Governance layer around custom agents built on the Anthropic SDK — intercept tool calls, evaluate against the corpus, return structured verdicts.

Decision corpus

### ADR import

Bring existing architecture decision records into the governance corpus so they become enforceable, not just documented.

## Why governance matters at agent scale

As Claude-powered development scales beyond a single developer-and-agent loop, new failure modes emerge that no single marketplace layer addresses:

- Architectural drift — each agent makes locally rational choices that compound into system-wide inconsistency
- Multi-agent inconsistency — one agent’s output contradicts another’s on the same surface
- Long-running workflows — context decays, prompts drift, invariants quietly stop holding
- Prompt entropy — rules that worked in one session get diluted in the next
- Governance propagation gaps — a constraint enforced in one tool is missing in the next

The fix is not more context, more tracing, or more reviewers. It is a deterministic governance layer that travels with the repo and reaches every Claude-powered surface that touches the code.

The Claude Marketplace validates the existence of the stack. Mneme is the layer that keeps the stack from drifting as it scales.

## Protect architectural decisions before drift reaches production

Open-source. Repo-native. Works alongside Claude Code, marketplace partners, CI, and any other Claude-powered surface that touches the codebase.

GitHub All works-with Read the analysis