Project Memory

Feature

The AI Memory Layer that captures architectural patterns and team standards from your development workflow, making Arbtr the persistent memory for AI coding assistants.

What is Project Memory?

Project Memory is Arbtr's AI Memory Layer - a system that automatically captures architectural choices made during development and aggregates them into team-wide standards. It bridges the gap between individual coding sessions and institutional knowledge.

When AI coding assistants (Claude Code, Cursor, Windsurf, etc.) work on your projects, Project Memory captures the “whys” and “whats” of their choices. Over time, these individual choices are aggregated into patterns, and patterns that appear across multiple projects can be promoted to team standards.

The result: AI assistants that remember your team's preferences, follow established conventions, and help enforce architectural decisions - even across different projects and team members.

Project Memory requires MCP integration. See the MCP Integration guide to set up your AI coding assistant.

Why Project Memory?

AI coding assistants are powerful, but they have no memory between sessions. Every time you start a new conversation, the AI forgets:

Which libraries your team prefers (and which are banned)
Your architectural patterns and conventions
Previous decisions that affect the current task
Why certain approaches were chosen over others

Project Memory solves this by giving AI assistants persistent context about your team's standards. When an AI assistant connects via MCP, it receives:

Team standards that should guide its suggestions
Project-specific patterns it should follow
Warnings about approaches that conflict with your architecture

Accessing Project Memory

Navigate to the Project Memory page from the main navigation:

Click the Project Memory link in the sidebar (brain icon)
Or navigate directly to /[team]/project-memory

The Project Memory page has three tabs:

Repositories

Lists all projects connected via MCP, showing the git remote URL, last activity, and number of detected patterns. Click a repository to see its patterns.

Patterns

Shows aggregated patterns across all projects. Each pattern displays its type, observation count, confidence score, and when it was last observed. Patterns can be promoted to team standards.

Standards

Team-wide rules that AI assistants follow. Shows enforcement level (Suggest/Warn/Block), linked decisions, and whether the standard was promoted from a pattern or created manually.

The Knowledge Hierarchy

Project Memory organizes knowledge in three levels, from raw data to actionable rules:

1. Developer Choices

Individual decisions made by AI assistants during development sessions. These are logged automatically via the log_choice MCP tool. Choices are fire-and-forget - they don't interrupt the workflow.

Examples:

“Used React Query for data fetching”
“Implemented repository pattern for database access”
“Added Prisma ORM for type-safe queries”
“Used Zod for runtime validation”

2. Project Patterns

When the same choice appears multiple times in a project, it becomes a recognized pattern. Patterns have confidence scores based on observation frequency - more observations means higher confidence.

Pattern properties:

Observation count: How many times this pattern was logged
Confidence: 0-100% score based on consistency
Last observed: When the pattern was last seen
Type: dependency, pattern, convention, architecture, etc.

3. Team Standards

Patterns that appear across multiple projects can be promoted to team-wide standards. Standards have enforcement levels that affect how AI assistants respond to them.

Standard properties:

Enforcement level: Suggest, Warn, or Block
Backing decision: Optional link to an architecture decision
Description: Explanation of why this is a standard
Rule: The specific key/value that defines the standard

Standard Types

Standards can cover different aspects of your architecture:

dependency

Preferred or blocked libraries and packages. Example: “Use date-fns instead of moment.js”

pattern

Code patterns and design approaches. Example: “Use repository pattern for data access”

convention

Naming and structural conventions. Example: “Use kebab-case for file names”

architecture

High-level architectural patterns. Example: “Use event-driven architecture for services”

stack

Technology stack choices. Example: “Use PostgreSQL for relational data”

config

Configuration preferences. Example: “Enable strict TypeScript mode”

MCP Tools for AI Assistants

Project Memory provides three MCP tools that AI coding assistants use automatically:

get_project_context

Retrieves team standards and project-specific patterns for a given repository. AI assistants call this at the start of sessions to understand guidelines.

// Called with the git remote URL
get_project_context({
  git_remote: "git@github.com:acme/backend.git"
})

// Response includes:
{
  team_standards: [
    { name: "Use React Query", type: "dependency", enforcement: "suggest" },
    { name: "No moment.js", type: "dependency", enforcement: "block" }
  ],
  project_patterns: [
    { key: "state-management", value: "zustand", confidence: 0.85 }
  ]
}

log_choice

Fire-and-forget logging of architectural choices. AI assistants call this when making significant decisions during development. Does not block or wait for a response.

// Example: logging a dependency choice
log_choice({
  git_remote: "git@github.com:acme/backend.git",
  choice_type: "dependency",
  key: "orm",
  value: "prisma",
  description: "Added Prisma ORM for type-safe database queries",
  reasoning: "Need type safety and good DX for database operations",
  confidence: 0.8
})

check_standards

Validates a proposed choice against team standards before implementation. Returns any conflicts or recommendations.

// Check before adding a dependency
check_standards({
  choice_type: "dependency",
  key: "date-library",
  value: "moment"
})

// Response:
{
  aligned: false,
  conflicts: [
    {
      standard: "No moment.js",
      enforcement: "block",
      reason: "moment.js is deprecated, use date-fns"
    }
  ],
  suggestions: ["date-fns", "dayjs"]
}

Promoting Patterns to Standards

When you notice a pattern that should become a team-wide rule, you can promote it to a standard:

Navigate to the Patterns tab in Project Memory
Find the pattern you want to promote
Click the Promote to Standard button
In the modal, configure:
- Name: A clear name for the standard
- Description: Why this is important (use AI generation for help)
- Enforcement Level: How strictly to enforce
- Backing Decision: Optionally link to an architecture decision
Click Create Standard

tip

Use the “Generate with AI” button to automatically create a professional description that explains what the standard requires and why it's important.

Enforcement Levels

Each standard has an enforcement level that determines how AI assistants respond when a proposed choice conflicts with the standard:

Suggest

AI assistants see this as a gentle recommendation. The standard appears in context but doesn't trigger warnings.

Best for: Preferences, soft guidelines, newer standards being evaluated

Warn

AI assistants will warn the user if a choice conflicts with this standard, but won't prevent it. The user can proceed if they have a good reason.

Best for: Important conventions that may have valid exceptions

Block

AI assistants will actively prevent choices that violate this standard and suggest compliant alternatives.

Best for: Security requirements, deprecated libraries, critical architecture rules

Emerging Patterns

When the same pattern appears across multiple projects (2+), Arbtr detects it as an “emerging pattern” and creates an Arbiter insight suggesting you promote it to a team standard.

This helps teams discover de facto standards - conventions that have organically emerged from development practices across the organization. These are often the most valuable standards because they reflect what actually works in practice.

How Emerging Pattern Detection Works

A daily aggregation job processes all developer choices
Choices with the same type + key + value are grouped into patterns
Patterns appearing in 2+ projects are flagged as “emerging”
An Arbiter insight is created to notify the team
The insight appears in your inbox with a “Promote to Standard” action

tip

Check the Arbiter insights panel regularly for emerging patterns. Patterns with high confidence (80%+) appearing in 3+ projects are strong candidates for team standards.

Standards Alignment Badges

When you link a standard to a backing decision, that decision displays a “Backs N Standards” badge. This provides traceability between your architectural decisions and the standards that enforce them.

Click the badge to see which standards are linked to the decision, including their enforcement levels. This helps team members understand the real-world impact of architecture decisions.

Common Use Cases

Enforcing Library Choices

Your team decided to use date-fns instead of moment.js. Create a “Block” standard for moment.js. Now when any AI assistant tries to add moment.js, it will be blocked and date-fns will be suggested instead.

Spreading Best Practices

One project discovered that using Zod for validation works well. After a few weeks, Project Memory detects this as an emerging pattern across projects. Promote it to a “Suggest” standard so other projects adopt it too.

Onboarding New Team Members

When new developers join and use AI assistants, they automatically receive context about team standards. No need to read documentation - the AI knows the rules and guides them appropriately.

Migrating Away from Legacy

Create a “Warn” standard for the legacy approach while promoting the new one. AI assistants will gently steer developers toward the new approach while allowing exceptions for legacy code maintenance.

How It Works (Technical)

Project Identification: AI assistants identify projects by their git remote URL (e.g., git@github.com:acme/backend.git). This URL is parsed and normalized to handle different formats (SSH, HTTPS).
Context Loading: At session start, assistants callget_project_context to fetch standards and patterns. This happens automatically if your AI assistant is configured with Arbtr MCP.
Choice Logging: During development, assistants calllog_choice to record architectural decisions. This is fire-and-forget and doesn't interrupt the workflow.
Background Aggregation: A daily cron job aggregates choices into patterns. Choices with the same type, key, and value are grouped together.
Emerging Pattern Detection: The aggregation job identifies patterns appearing across 2+ projects and creates Arbiter insights.
Insight Notification: Emerging patterns appear in the Arbiter insights panel with a suggested “Promote to Standard” action.

Best Practices

Start with Suggest: When promoting a new pattern to a standard, start with “Suggest” enforcement. Upgrade to “Warn” or “Block” once the team has validated it.
Link to Decisions: Always link standards to backing decisions when possible. This provides documentation and justification for why the standard exists.
Review Emerging Patterns: Check the Arbiter insights weekly for emerging patterns. These represent organic team consensus and are often the best candidates for standards.
Be Specific: Standards work best when they're specific. Instead of “Use good naming conventions”, create specific standards like “Use kebab-case for file names” or “Prefix hooks with use”.
Document Exceptions: If a standard has valid exceptions, note them in the description. This helps AI assistants understand when the standard might not apply.

Frequently Asked Questions

Do I need to manually log choices?

No. If your AI assistant is configured with Arbtr MCP, it will automatically log choices when making significant architectural decisions. The logging is fire-and-forget and doesn't require any action from you.

Can I create standards without patterns?

Yes. You can create standards directly from the Standards tab without waiting for patterns to emerge. This is useful for established conventions you want to enforce immediately.

What happens if I delete a standard?

The standard is removed from the team context. AI assistants will no longer receive it when fetching project context. Existing patterns that were promoted to this standard remain intact.

How often is choice aggregation run?

The aggregation cron job runs daily. This means patterns and emerging pattern insights may take up to 24 hours to appear after choices are logged.

Can I see which AI assistant logged a choice?

Currently, choices are associated with the MCP API key used, not the specific AI assistant. All assistants using the same team API key appear as the same source.

Arbiter Insights

MCP Integration

Command Palette