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.
Language coverage
Strongest support and validation coverage. Native CLI/runtime implementation, real-world benchmark coverage, and dogfooding in production repos.
- 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
- Backend services and APIs (FastAPI, Django, Flask)
- AI/ML pipelines
- CLI tooling and automation
- Governance enforcement in Python repos
Strong compatibility with Mneme's governance model. Repository-level enforcement works today; semantic and AST-aware layers are roadmap.
- Repository-level governance
- Architectural boundary enforcement
- Forbidden dependency checks
- Path and scope governance
- Agent workflow governance
- Compatible with Cursor, Claude Code, and Copilot workflows
- 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)
- React and Next.js applications
- Node.js backends
- Monorepos (npm/pnpm/yarn workspaces, Turborepo, Nx)
- AI-assisted frontend development
Conceptually supported through repo-level governance. Architectural and dependency rules apply; semantic checks are not yet specialized.
- Architectural boundary enforcement (cmd/, internal/, pkg/ conventions)
- Dependency governance (go.mod allow-listing, forbidden imports)
- ADR enforcement
- CI workflow governance
Compatible with Mneme's governance model. Layered architecture and ADR enforcement work; Spring/Maven-aware policy packs are roadmap.
- Layering enforcement (controllers, services, repositories)
- Architectural constraints
- Repository-level governance
- CI integration support
- AI workflow governance across IntelliJ + agent surfaces
Compatible with Mneme's governance model. .NET solution layout and dependency rules work; Roslyn-assisted depth is roadmap.
- Architectural governance (project boundaries, namespace rules)
- Repository policy enforcement
- Dependency constraints (NuGet allow-listing)
- Workflow governance
Compatible with Mneme's governance model. Workspace and crate-level rules apply; clippy/rustc-assisted depth is roadmap.
- 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.