Reference

# Supported programming languages and governance scope

Mneme is an architectural governance layer for AI-assisted development. It operates at the repository, workflow, and governance level — not at the language parser or compiler level. That means it is fundamentally language-agnostic today, while practical depth varies by runtime integration, benchmark coverage, and ecosystem-specific tooling.

## Current support model

Mneme provides:

- Repository-aware governance over file paths, ownership scopes, and protected directories.
- Architectural decision enforcement via a structured decision corpus with precedence resolution.
- Workflow and policy validation at the pre-generation seam (Claude Code hooks, Cursor rules, CI checks).
- Anti-pattern detection on AI-generated diffs.
- Constraint injection into the agent's system prompt before generation.
- Governance checks for local workflows and CI pipelines.

Mneme does not currently depend on a language-specific compiler or AST engine for core functionality. This is a deliberate design choice — see strategic positioning.

The frame. "Mneme supports Python" is the wrong question. The right question is: does Mneme provide architectural governance for AI-assisted Python development? The answer is yes for every language listed below, with depth varying by integration tier.

## Language coverage

Python Tier 1 · production-grade

Strongest support and validation coverage. Native CLI/runtime implementation, real-world benchmark coverage, and dogfooding in production repos.

Current capabilities

- Native CLI/runtime implementation
- Real-world benchmark coverage
- Governance enforcement validation
- Claude Code hook integration
- CI / GitHub Actions support
- ADR-driven architectural enforcement
- Dogfooding validation in production repositories

Typical use cases

- Backend services and APIs (FastAPI, Django, Flask)
- AI/ML pipelines
- CLI tooling and automation
- Governance enforcement in Python repos

Python governance page →
TypeScript & JavaScript Tier 1 · operationally supported

Strong compatibility with Mneme's governance model. Repository-level enforcement works today; semantic and AST-aware layers are roadmap.

Current capabilities

- Repository-level governance
- Architectural boundary enforcement
- Forbidden dependency checks
- Path and scope governance
- Agent workflow governance
- Compatible with Cursor, Claude Code, and Copilot workflows

Current limitations

- No TypeScript semantic analysis layer yet
- No AST-native governance engine yet
- No framework-specific enforcement today (React, Next.js, Express patterns are governed at the file/dependency level, not the component level)

Typical use cases

- React and Next.js applications
- Node.js backends
- Monorepos (npm/pnpm/yarn workspaces, Turborepo, Nx)
- AI-assisted frontend development

TypeScript governance page → · JavaScript governance page →
Go Tier 2 · repo-level governance

Conceptually supported through repo-level governance. Architectural and dependency rules apply; semantic checks are not yet specialized.

Current capabilities

- Architectural boundary enforcement (cmd/, internal/, pkg/ conventions)
- Dependency governance (go.mod allow-listing, forbidden imports)
- ADR enforcement
- CI workflow governance

Java Tier 2 · repo-level governance

Compatible with Mneme's governance model. Layered architecture and ADR enforcement work; Spring/Maven-aware policy packs are roadmap.

Current capabilities

- Layering enforcement (controllers, services, repositories)
- Architectural constraints
- Repository-level governance
- CI integration support
- AI workflow governance across IntelliJ + agent surfaces

C# Tier 2 · repo-level governance

Compatible with Mneme's governance model. .NET solution layout and dependency rules work; Roslyn-assisted depth is roadmap.

Current capabilities

- Architectural governance (project boundaries, namespace rules)
- Repository policy enforcement
- Dependency constraints (NuGet allow-listing)
- Workflow governance

Rust Tier 2 · repo-level governance

Compatible with Mneme's governance model. Workspace and crate-level rules apply; clippy/rustc-assisted depth is roadmap.

Current capabilities

- Repository-level governance
- Architectural enforcement (workspace structure, crate boundaries)
- AI agent governance
- Workflow validation

## Integration-based compatibility

Mneme operates above the model and runtime layer. Any development workflow using the following inherits governance support, regardless of underlying language:

- Cursor
- Claude Code
- GitHub Copilot
- Custom AI coding agents (LangGraph, AutoGen, CrewAI, OpenAI Agents SDK)
- Agent runtimes (Anthropic API, OpenAI API, OpenAI-compatible endpoints)
- CI/CD pipelines (GitHub Actions, GitLab CI, CircleCI, others)
- Hook-based development workflows

See the Works With page for the full compatibility surface.

## What Mneme governs today

- Architectural decision continuity (ADR enforcement, supersession resolution)
- Path restrictions (protected directories, ownership boundaries)
- Dependency restrictions (banned libraries, licensing constraints)
- Scope governance (which agent / which team / which PR can touch what)
- Anti-pattern prevention
- Workflow policy enforcement
- Pre-generation governance checks

For concrete worked examples, see /docs/governance-violations/.

## What Mneme does not yet provide

- Compiler awareness
- AST-aware enforcement
- Framework-semantic awareness (React component-level, Spring annotation-level, etc.)
- Language-parser-native checks
- Deep static-analysis-native enforcement

Today, Mneme governs architectural and workflow behavior rather than performing deep language semantics. That distinction is intentional — the next section covers why.

## Future direction

Potential future capabilities under consideration:

- TypeScript semantic governance (AST-aware rules)
- React architecture enforcement (component boundaries, hooks rules)
- Spring Boot governance packs (controller/service/repository layering)
- FastAPI architectural governance (route / service / data layer rules)
- Terraform policy governance
- Framework-specific policy packs
- Compiler and AST-assisted enforcement
- Semantic architectural validation

This direction would evolve Mneme from repository-aware governance toward compiler-aware architectural governance. See the roadmap.

## Strategic positioning

Mneme intentionally prioritizes cross-language governance before deep language specialization. This architecture allows:

- Faster ecosystem coverage
- Runtime-agnostic governance
- Lower integration maintenance burden
- Consistent governance semantics across heterogeneous agent environments
- Architectural governance across mixed-language repositories and teams

The long-term direction is not simply language support. It is governed AI-assisted software development across heterogeneous engineering environments. Adding deeper language semantics where it pays off — not by default for every ecosystem at once.

Why repo-first, not parser-first
Parser-first governance
Has to ship a new analyzer per language and per framework. Coverage gaps. Slower to extend.
Repo-first governance (Mneme)
One enforcement model covers every language a team writes. Adds semantic depth where benchmarks and demand justify it.
Marketing Supported languages hub → The shorter, positioning-focused version of this page. What it catches Governance violations → Twelve worked examples of the violations enforced regardless of language. Operations CLI reference → Commands and CI patterns that operate on any language repo.