Open Source — BSL 1.1

Contracts replace codebases.

ANMA is an AI-native project architecture. Your AI agent reads 6 files and understands your entire system. No scanning. No guessing. No wasted tokens.

Get Started How It Works

Proven in production

$31

Total cost to scaffold a full app

18modules

104 interfaces implemented

14.6k tokens

To understand the entire system

28k lines

Generated in one session

48min

API time for all 18 modules

The Problem

AI agents waste most of their tokens understanding your code.

Every time an AI coding agent starts a task, it scans your source files, infers interfaces, guesses at conventions, and reads imports to understand what to build. This understanding phase burns 70-80% of your context window before a single line of code is written.

ANMA inverts this. Instead of dumping your codebase into context and hoping the model figures it out, you write contracts that define your system in ~250 tokens per module. The AI reads 6 files and starts building immediately.

Without ANMA~150,000 tokens

Scanning, guessing, inferring

With ANMA~14,600 tokens

Done.

How It Works

Six files. Full context. Zero ramp-up.

Define contracts

Each module gets a CONTRACT.yaml — inputs, outputs, error codes, and behavioral invariants. This is what your AI agent reads instead of source code. ~250 tokens per module.

Map dependencies

GRAPH.yaml defines which modules consume which. MANIFEST.yaml tracks status. The AI knows build order, blast radius, and what's safe to change.

Build and validate

Point any AI coding agent at your contracts. It implements interfaces exactly as specified. The linter validates everything — 23 checks, zero tolerance for drift.

See it work.

~/my-project

      $ python3 tools/lint_contracts.py
      
      Checking CONVENTIONS.yaml... OK
      Checking MANIFEST.yaml... OK
      Checking GRAPH.yaml... OK
      Checking modules/user-auth/CONTRACT.yaml... OK
      Checking modules/todo-api/CONTRACT.yaml... OK
      Checking modules/notifications/CONTRACT.yaml... OK
      
      ✓ 0 errors, 3 warnings
      Total context budget: ~1,200 tokens per module
      Full recovery: 6 files → any agent, any time
    

The 6-File Recovery Pattern

Any agent. Any time. Zero ramp-up.

A new AI agent reads these 6 files and has full context to continue building. No onboarding, no "let me scan the codebase," no hallucinated interfaces.

CONVENTIONS.yaml

Naming rules, patterns, and standards every module follows

~850 tokens

MANIFEST.yaml

All modules, their status, and ownership

~220 tokens

GRAPH.yaml

Dependency edges between modules

~440 tokens

CONTRACT.yaml

Interfaces, inputs, outputs, error codes, behavioral invariants

~250 tokens per module

STATE.yaml

Current implementation status and health

~40 tokens

MEMORY.yaml

What the last agent learned — edge cases, decisions, gotchas

~30 tokens

Start building.

Clone the repo. Run the linter. Read a contract. You'll get it in 5 minutes.

View on GitHub Read the Quickstart