Mneme governs decisions, not syntax, so its enforcement is language-agnostic. It ships production-grade depth for Python and operational support for TypeScript and JavaScript (Tier 1), plus Tier 2 repository-level governance for Go, Java, C#, and Rust, with the same architectural, dependency, and workflow rules applied across every language a team writes.

Reference

Supported programming languages and governance scope

Mneme is the decision and control layer for agentic software development, with architecture as the first decision domain. 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.