# Agentic Architect

> A free single-rule preview of the Agentic Architect Persistence Framework for Cursor, providing directory-scoped architecture boundary enforcement for C#/.NET codebases.

Agentic Architect is a persistence framework for the Cursor AI coding assistant, built specifically for senior C#/.NET engineers. The project ships as a set of directory-scoped `.mdc` rule files that plug into Cursor's native rules system, giving the AI persistent architectural context across sessions. The free preview file, `arch-core-lite.mdc`, is a single production-ready rule that demonstrates the boundary-guardian approach before committing to the full paid kit.

## What It Is

Agentic Architect addresses what the project calls the "Context Tax" — the daily overhead of re-explaining DI patterns, layer boundaries, and architectural decisions to an AI that forgets everything when a chat session closes. Rather than relying on chat prompts, the framework commits `.mdc` rule files directly into the `.cursor/rules/` directory of a project repository. Cursor auto-detects and loads only the rules that match the current file path, keeping token usage lean and guardrails relevant.

The free `arch-core-lite.mdc` file is a real, stripped-down version of the core `arch-core.mdc` rule. It enforces SOLID layer boundaries — for example, refusing to import EF Core into the Domain layer — and serves as a no-signup preview of the full framework's approach.

## How the Persistence Protocol Works

The full kit (sold separately) extends the free preview with eight additional specialist rules and a stateful `LEARNING_LOG.md` workflow:

- **`arch-core.mdc`** — detects which Clean Architecture layer the current file belongs to (Domain, Application, Infrastructure, API) and blocks cross-layer suggestions
- **`dotnet-di.mdc`** — audits constructor injection and service lifetimes; catches Scoped→Singleton capture bugs before runtime
- **`bug-breaker.mdc`** — a circuit breaker that halts generation after repeated failed attempts on the same file, forcing a re-read of the real source interface
- **`persistence.mdc`** — the core engine; appends architectural decisions to `LEARNING_LOG.md` in ADR style and hydrates them at the start of each new session

The hydrate prompt runs once to seed the log from an existing codebase; after that, `persistence.mdc` maintains the log automatically across sessions.

## Target Audience and Use Cases

The project targets senior, staff, and principal C#/.NET engineers who use Cursor daily on production codebases running Clean Architecture, MediatR, Result\<T\>, and EF Core. The website lists specific problems the rules are designed to catch: context re-briefing overhead, Scoped→Singleton DI lifetime bugs, hallucination loops on non-existent methods, Result\<T\> regression (blocking `throw` in controllers), and EF Core anti-patterns such as missing `AsNoTracking` or N+1 queries.

The project notes that `persistence.mdc` and `bug-breaker.mdc` are language-agnostic, while seven of the nine rules in the full kit are tuned specifically for the .NET ecosystem.

## Deployment Model

Installation requires no build step, CLI, or config file editing. The workflow is:

1. Copy `.cursor/rules/` into the repository root
2. Add `LEARNING_LOG.md` from the included template
3. Run the one-shot hydrate prompt to seed the log from the existing codebase
4. Commit both the rules folder and the log to version control

The MIT license explicitly permits committing the rules and log into team repositories and using them across multiple internal repos. The free `arch-core-lite.mdc` file is available directly from the GitHub repository with no signup required.

## Current Status

The repository was created in April 2026 and last updated in June 2026. The project is in active early-access ("Founder's Edition") status. The website notes the current price is a founder's rate that will increase when a video walkthrough ships. The GitHub repository is MIT-licensed and publicly available, with the full paid kit distributed via Payhip as an instant ZIP download.

## Features
- Free single-rule preview (arch-core-lite.mdc) with no signup required
- Directory-scoped .mdc rules that load only for matching file paths
- SOLID layer boundary enforcement for Clean Architecture
- DI lifetime auditor catching Scoped→Singleton capture bugs
- Circuit breaker (bug-breaker.mdc) halting hallucination loops after repeated failures
- Stateful LEARNING_LOG.md protocol for cross-session architectural memory
- ADR-style log entries hydrated at session start via persistence.mdc
- One-shot hydrate prompt to seed log from existing codebase
- MIT license for team repository use
- Lifetime updates via repository access

## Integrations
Cursor AI, C#/.NET, Clean Architecture, MediatR, EF Core, Result<T>, IServiceCollection, Scrutor, Autofac, Payhip

## Platforms
MACOS, WEB, API, CLI

## Pricing
Freemium — Free tier available with paid upgrades

## Version
Founder's Edition

## Links
- Website: https://agentic-architect.dev
- Documentation: https://agentic-architect.dev/learn/cursor-rules-dotnet.html
- Repository: https://github.com/agenticstandardcontact-byte/agentic-architect
- EveryDev.ai: https://www.everydev.ai/tools/agentic-architect