aidimag

AI Dimag — Verified Memory for AI Coding Agents

Your coding agent forgets your codebase. AIDimag doesn't.

Documentation • Why AIDimag? • Getting Started • Use Cases • Benchmarks • AI Dimag Cloud • Pricing

---

What is AI Dimag?

AI Dimag is a memory system for software engineering — not a general-purpose "AI memory" app. It gives any MCP-compatible agent (Claude, Cursor, Copilot, Windsurf…) a persistent memory of your codebase that survives across sessions — decisions, conventions, gotchas, failed approaches, guardrails, and reusable skills — stored as falsifiable claims with grounding evidence in .aidimag/ next to your code.

The subject of memory is your repository, not your preferences or chat history. Every capability — evidence, git-hook verification, guardrails, pre-commit checks, path-scoped recall, session scratchpad — exists to serve day-to-day development work.

The Difference: Claim-and-Verify, Not Store-and-Retrieve

Most memory systems store text and retrieve whatever is similar later — a stored fact is assumed true forever. That's dangerous in a codebase, where a confidently-retrieved stale fact is worse than no memory at all.

Every AI Dimag memory carries evidence (a shell check, an anchored commit, a test) that dim verify re-runs against the current repo — automatically, via git hooks, on every pull, checkout, and rebase. Beliefs that stop being true go STALE instead of silently misleading your AI.

Works with Every AI Tool

• MCP tools (Claude, Cursor, etc.) get real-time memory via the MCP server
• Non-MCP tools (Copilot, Windsurf, etc.) get static context files (.cursorrules, CLAUDE.md, AGENTS.md, etc.)

Install

npm install -g aidimag

Requires Node 22+. Ships two equivalent binaries: dim (short) and aidimag.

Quick Start

cd your-repo
dim init                    # creates .aidimag/, installs additive git hooks
dim bootstrap               # optional: LLM-survey the repo into a starter memory set
dim review                  # approve what enters memory (nothing is stored unreviewed)

dim remember "All DB access goes through src/db/store.ts" -k INVARIANT -p src \
  -e "STATIC_CHECK:! grep -rl better-sqlite3 src --include=*.ts | grep -v store.ts"
dim recall db access
dim verify                  # re-run all evidence; stale beliefs get flagged
dim brief                   # session-start briefing: in-scope memory, guardrails, gaps

# For non-MCP tools (Copilot, Cursor without MCP, etc.):
dim generate-context --format all --auto   # creates .cursorrules, CLAUDE.md, AGENTS.md, etc.

One-command setup

dim setup --yes              # init + git hooks + MCP configs for detected agents + context files
dim setup-ollama             # install Ollama + pull a free local embedding model for semantic search
dim doctor                   # verify everything is wired correctly

Connect to Your AI Agent (MCP)

Add to your agent config (e.g. .mcp.json for Claude Code):

{
  "mcpServers": {
    "aidimag": {
      "command": "npx",
      "args": ["-y", "aidimag", "mcp"],
      "env": { "AIDIMAG_REPO": "/path/to/your/repo" }
    }
  }
}

MCP Tools get memory_search, memory_propose, context_note (live in-chat fact capture), chat_harvest (live, tool-agnostic session harvesting with server-side secret redaction), memory_critique (a second critic grounded in verified memory), session-start briefings, session-end extraction, and more.

Non-MCP Tools: dim generate-context -f all renders verified memory into .cursorrules, CLAUDE.md, AGENTS.md, .windsurfrules, and .github/copilot-instructions.md (--auto keeps them refreshed).

Hermes Agent: dim hermes install registers aidimag as a native Hermes memory provider — one command, no pip, no venv. A single stdlib-only Python bridge delegates to the MCP server: session briefings are injected into the system prompt, recall is prefetched per turn, and session learnings become review-queue proposals (never silent writes). Then: hermes config set memory.provider aidimag.

Key Features

Human-Gated Capture

Commits, PRs, AI-chat transcripts (Claude Code, Codex, Copilot, Cursor), and pasted docs are mined into proposals. Nothing enters memory until you approve it in dim review (auto-triaged best-first, approve all --min-score 0.7 for batches).

Verification Lifecycle

STATIC_CHECK / COMMIT_REF / TEST_RESULT / EXEC_TRACE / HUMAN_ATTESTED evidence. Failing evidence flips memories to STALE and auto-drafts a recovery proposal. Confidence decays without re-confirmation.

Evidence Trust Gate

Shell-command evidence that arrives via team sync is never executed until you inspect and approve it (dim verify --trust).

Hybrid Semantic Recall

FTS5 keyword + vector KNN (OpenAI, local Ollama, or AWS Bedrock; auto-detected except Bedrock, which is explicit opt-in; works keyword-only with none).

Guardrails & Skills

Behavioral rules (never / ask-first / always) and step-by-step procedures, enforced by dim check (pre-commit) and memory_critique.

Team Mode, Self-Hosted

dim serve + dim sync: local-first replicas, device-code login, brain-scoped API keys, hashed credentials, cross-machine verification consensus.

Knowledgebase Inbox

Drop design docs / ADRs / PDFs / DOCX into knowledge/ and they're summarized into reviewed, pinned memories.

Scratchpad & Provenance Audit

dim scratch (and the scratchpad_* MCP tools) hold short-term session notes — TTL-expiring, never synced, never durable memory. dim audit lists memories resting on the weakest ground (agent-authored, evidence-free, stale, or long-unverified) so you can fix them up like a dependency audit for your repo's knowledge.

Web Dashboard & Extensions

dim ui — run checks, session briefings, bootstrap, harvest, and context generation from the browser — plus VS Code and IntelliJ extensions.

Ticketing Integration

Commits tell you what changed; tickets hold the why. aiDimag connects to your ticketing system so that context flows into your memory — ticket titles, types, and statuses appear next to mined proposals during dim review, and agents can fetch tickets via the ticket_get MCP tool.

Supported providers

Jira, GitHub Issues, Linear, GitLab Issues, Azure DevOps, ClickUp, Shortcut, YouTrack, Asana, Trello, Notion, Pivotal Tracker, a custom HTTP middleware, or Remote (team sync server — zero local credentials).

Quick start

# Connect a provider (interactive)
dim ticket connect

# Check status
dim ticket status

# View a specific ticket
dim ticket show XXX-2100

# Share credentials with your team (admin)
dim ticket share

Per-repo credential storage

Ticket credentials are stored per-repo in .aidimag/config.json under tickets.token (with file mode 0o600), matching the same pattern as cloud sync tokens. Credentials never leak between projects. You can also set the AIDIMAG_TICKET_TOKEN environment variable, which takes precedence over the config file.

Team-shared tickets (Remote provider)

One admin shares their ticket credential via the sync server (dim ticket share). Team members select "Remote (team sync server)" as their provider — they resolve tickets through the server and hold zero ticket credentials locally. When a cloud server is linked, the dashboard auto-discovers the team's ticket provider and shows a "Connect now" button.

Branch conventions

Define a branch-naming convention and have aiDimag warn or block on violations:

dim ticket branch-rule        # manage the convention
dim branch XXX-2100           # create a conforming branch (fetches title for slug)

Enforcement	Effect
off	No checking
warn	Heads-up at branch creation (post-checkout)
push	Blocks pushing non-conforming branches (pre-push)

Full guide: Connecting tickets

How It Compares

AI Dimag follows a claim-and-verify model; other memory systems follow store-and-retrieve. The short version:

	Conversational memory layers	Vector-store memory plugins	Hand-maintained context files	AI Dimag
Built for	Chat assistants remembering users	General recall over embedded text	Static instructions for coding agents	Coding agents in a living repo
Unit of memory	Extracted facts / chat summaries	Embedded text chunks	Prose	Falsifiable, typed claims with evidence
How memory gets in	Automatic capture	Automatic embedding	Manual edits	Human-gated review queue
When the code changes	Nothing — stored facts stay "true"	Nothing	File silently rots	Evidence re-runs via git hooks; broken claims flip STALE
Trust model	Write-time label, never re-checked	Similarity ≈ trust	"It's in the file"	Verification status + decaying confidence; trust-ranked retrieval
Enforcement	None — injection only	None	Hope the model reads it	Guardrails + pre-commit dim check + memory_critique
Failure mode	Confidently recalls outdated facts	Retrieves similar, true or not	Instructions drift from reality	Says "this went STALE" instead of guessing

Full comparison: aidimag.com/comparison

vs. named tools

How aiDimag relates to the memory tools people usually ask about. These solve a different problem (remembering users and conversations); aiDimag remembers your repository and proves its memories are still true:

	aiDimag	Mnemosyne	mem0	Letta	Honcho	SuperMemory	Hindsight	ChromaDB
Subject of memory	Your codebase	Chat/agent sessions	User & agent facts	Agent's own context	User/peer reasoning	Personal + agent	Agent memory	— (vector DB)
Local-first	✅ SQLite per repo	✅ SQLite	⚠️ Hybrid	❌ Docker+PG	⚠️ PG+worker	❌ SaaS	✅ SQLite	✅ Embedded
MCP server	✅ Built-in	✅	❌	❌	❌	✅	✅	❌
Verifies memories against code	✅ Evidence re-runs via git hooks	❌	❌	❌	❌	❌	❌	❌
Human-gated writes	✅ Review queue	❌ Auto-capture	❌ Auto	❌	❌	❌	❌	—
Enforcement	✅ Guardrails + pre-commit + critique	❌	❌	❌	❌	❌	❌	❌
Open source	✅ MIT	✅ MIT	✅ Apache 2.0	✅ Apache 2.0	⚠️ AGPL	❌ Proprietary	✅ MIT	✅ Apache 2.0
Published benchmark	Own suite: 100% staleness detection, 0% FP	BEAM 65.2% / LongMemEval 98.9% R@All@5 (self-reported)	LoCoMo	LoCoMo 83.2%	LongMemEval 90.4%	MemoryBench 85.2%	BEAM 73.4% / LongMemEval 94.6%	—

Chat-memory benchmarks (LoCoMo, LongMemEval, BEAM) score recall over conversation histories, so they don't apply to aiDimag — its memory subject is the repo. Instead aiDimag publishes its own reproducible suite (below), including the metric none of the chat benchmarks measure: does memory notice when the code changes?

Benchmarks

Reproducible performance and quality suites live in benchmark/ (npm run bench, npm run bench:quality). Headline results (Apple M4, Node 24, 10,000-memory brain — full tables at aidimag.com/benchmarks):

Metric	Result
FTS keyword search	1.45ms p50
Vector KNN (768-dim, sqlite-vec)	4.15ms p50
Memory writes (transactional, incl. FTS + event log)	~5,400/s
CLI cold start (dim --help)	~41ms p50
Staleness detection (broken claims → STALE, real git fixture)	100% (4/4)
False positives (intact claims wrongly flagged)	0% (0/4)
Retrieval, keyword queries (Recall@1 / MRR, FTS-only)	1.00 / 1.00
Retrieval, paraphrase queries (FTS-only; hybrid closes this gap)	0.25 / 0.27

Documentation

Getting Started

• Installation
• Quick Start (5 min)
• Cloud Sync

Overview

• Why AIDimag?
• Use Cases
• How it Works
• Web Dashboard
• Comparison
• CLI Reference
• MCP Integration
• Configuration

Guides

• Team Sync
• Connecting Tickets
• Guardrails
• Context Files

Full documentation: aidimag.com

---

Contributing

Contributions welcome! See CONTRIBUTING.md for dev setup, project principles, and the PR checklist. All participation is governed by our Code of Conduct.

License & Pricing

AI Dimag is open source under the MIT License — free for everyone, any team size, forever. Use it, fork it, embed it.

The entire local-first product is free: CLI, MCP server, verification, guardrails, skills, IDE extensions, local dashboard, and self-hosted team sync (dim serve).

Want team sync without running a server? AI Dimag Cloud is an optional managed sync subscription — that's how the project stays funded and open source. See Pricing.

---

Built by Anup Khanal

Website • Documentation • Cloud • npm • License