Open-source alpha

Stop re-teaching your codebase to AI.

MemoryGuard keeps your project's agent context files accurate across sessions. Capture decisions, review what matters, supersede outdated facts, and sync clean context into AGENTS.md, CLAUDE.md, .github/copilot-instructions.md, MEMORY.md, and Cursor rules.

Star on GitHubRead quickstartRun the demo
Local-firstNo required LLM APIReview-first captureApache-2.0
MemoryGuard
CapturePendingContext SyncGenerated Files
Pending Review
Backend framework: Flask
Supersedes: FastAPIcodex-session.txt
Package manager: pnpm
Supersedes: npmcodex-session.txt
Sensitive value omitted
Reason: secret-looking token
Generated Context
AGENTS.md
CLAUDE.md
Copilot instructions
MEMORY.md
Cursor rules
$ memoryguard capture approve --all
$ memoryguard sync
✓ wrote 5 context files
Public OSS alphaCI passingApache-2.0Runs locallyNo required cloudNo required external LLM API
Core workflow

The context layer your coding tools are missing.

MemoryGuard is not a chatbot and not a generic notes app. It is a focused workflow for keeping agent-facing project context reviewed, current, and synced.

Sync

One memory store. Many agent files.

Render approved project memory into AGENTS.md, CLAUDE.md, Copilot instructions, MEMORY.md, and Cursor rules.

⇄
Capture

Turn sessions into reviewable memory.

Capture durable facts from Codex, Cursor, Claude, or plain local session files without trusting the whole transcript.

◎
Current

Old decisions stay old.

When FastAPI becomes Flask or npm becomes pnpm, MemoryGuard marks the replaced facts as superseded instead of letting them linger.

↻
Redact

Keep sensitive values out of context.

Secret-looking values are omitted from generated context as a best-effort guardrail.

◆
SQLite

Runs on your machine.

Project state lives locally under .memoryguard using SQLite in the alpha flow.

⬡
Offline

No hosted model dependency.

The core workflow runs without OpenAI, Anthropic, Gemini, or any required external model API.

⊘
Before and after

From stale notes to maintained context.

Before

  • This project uses FastAPI.
  • This project uses npm.
  • API key: sk-test-...

After

  • Backend framework: Flask.
  • Package manager: pnpm.
  • FastAPI was previously used; superseded by Flask.
  • Sensitive memory omitted from generated context.
Workflow

Capture. Review. Approve. Sync.

1

Capture

Point MemoryGuard at a transcript or session file.

memoryguard capture file ./session.txt
2

Review

Inspect pending candidates before they become durable context.

memoryguard capture pending
3

Approve

Promote only the facts that should survive future sessions.

memoryguard capture approve --all
4

Sync

Write clean context into the files your tools already inspect.

memoryguard sync
Install

One command. Then memoryguard demo.

Windows (PowerShell)

irm https://raw.githubusercontent.com/atharvmantri/MemoryGuard/main/scripts/install.ps1 | iex

macOS / Linux

curl -fsSL https://raw.githubusercontent.com/atharvmantri/MemoryGuard/main/scripts/install.sh | bash

Prerequisites: git + uv (no Node required for the CLI). After this finishes, memoryguard is on your PATH and works from any cwd — including C:\Windows\System32.

Advanced (from a clone): git clone && bash scripts/install-alpha.sh — or uv run memoryguard demo from a checkout.

memoryguard demo
$ memoryguard doctor
[ok] MemoryGuard CLI   running v0.1.0
[ok] Python            cpython 3.14.0
[ok] uv                on PATH
$ memoryguard demo
Agent Capture demo passed.
Extracted 10 candidates, approved 9, wrote 5 context files.
Context targets

The files your agents already read.

MemoryGuard writes managed context into familiar project files.

AGENTS.md
CLAUDE.md
.github/copilot-instructions.md
MEMORY.md
.cursor/rules/memoryguard.mdc
Positioning

Built for context files, not generic memory.

Most memory tools focus on storing or retrieving information. Manual agent files are simple, but they drift. MemoryGuard focuses on the practical middle: reviewed project memory that syncs into the files coding tools already read.

Manual agent files

  • easy to start
  • drift over time
  • copied across tools manually

Generic memory layers

  • useful for retrieval
  • often not context-file-first
  • may be too broad for daily coding workflow

MemoryGuard

  • review-first capture
  • context-file sync
  • supersession
  • secret omission
  • local-first alpha flow
Comparison

Built for agent context, not generic notes.

CapabilityManual filesGeneric memoryMemoryGuard
Syncs AGENTS.md / CLAUDE.md / Copilot / MEMORY.md / Cursor rules◐◐✓
Review-first transcript capture–◐✓
Supersedes outdated project decisions–◐✓
Secret-aware generated context–◐✓
Local-first alpha flow✓◐✓
No required external LLM API✓◐✓

MemoryGuard's advantage is not being the biggest memory system. Its advantage is being the focused Context Sync layer for the files coding agents already read.

Why MemoryGuard

Purpose-built for agent context.

  • Capture decisions from local session files
  • Review candidates before they become memory
  • Supersede outdated project facts
  • Generate the files coding tools already read
  • Keep multiple agent files aligned
  • Omit secret-looking values from generated context
  • Run locally without a required hosted model
  • Start from source during public alpha

Give your coding tools the context they keep asking for.

Start with the local alpha, run the demo, and inspect the generated context yourself.

Star on GitHubRead quickstart