
MemoryCustodian
MemoryCustodian bietet Codierungsagenten einen dauerhaften, Repository-nativen Projektspeicher, indem es Schlüsselkontext als einfaches Markdown speichert und nur aufgabenrelevante Teile über ein Manifest lädt, um den Prompt-Overhead über Sitzungen und Teams hinweg zu minimieren.
https://github.com/waittim/MemoryCustodian?ref=producthunt&utm_source=aipure

Produktinformationen
Aktualisiert:Jul 30, 2026
Was ist MemoryCustodian
MemoryCustodian ist ein leichtgewichtiges „Projektgedächtnis“-System für KI-Codierungsagenten, das ihnen hilft, wichtige Informationen über Sitzungen hinweg zu behalten – Entscheidungen, Einschränkungen, abgelehnte Ansätze und die aktuelle Projektform – ohne auf Chat-Verlauf oder überladene Anweisungs-Prompts angewiesen zu sein. Es speichert dauerhaften Kontext als überprüfbares, diffbares Markdown in Ihrem Repository (typischerweise unter `docs/memory/`) und bietet eine schnelle, Offline-First, Python (nur Standardbibliothek) CLI sowie Agenten-Integrationen (z. B. Codex, Claude Code, Gemini-ähnliche Fähigkeiten). Ziel ist es, Projektwissen über Agenten hinweg portierbar und für Menschen so einfach wie Code überprüfbar zu machen, während der Laufzeitkontext klein und intentional gehalten wird.
Hauptfunktionen von MemoryCustodian
MemoryCustodian ist ein "Projektgedächtnis"-System, das offline zuerst arbeitet und dauerhaften Kontext (Entscheidungen, Einschränkungen, abgelehnte Ansätze und aktuelle Projektform) als einfaches Markdown in Ihrem Repository speichert. Anstatt große Prompts einzufügen oder sich auf den Chatverlauf zu verlassen, verwendet es einen Manifest-ersten Workflow, um nur die aufgabenrelevanten Speicherdateien in den Kontext-Pack eines Agenten zu laden. Dies hält Sitzungen schlank, während Wissen überprüfbar, diff-fähig, über Agenten/Teams portierbar und über eine deterministische, nur auf der Standardbibliothek basierende Python-CLI mit geschützten Preview-First-Mutationen (z. B. komprimieren/vergessen/migrieren) wartbar ist.
Repo-natives Markdown-Gedächtnis: Speichert dauerhaftes Projektwissen unter `docs/memory/` als einfaches Markdown, sodass Menschen das Gedächtnis wie Code überprüfen, diffen, committen und zurücksetzen können – keine Vektor-DB, RAG-Index oder Cloud-Abhängigkeit erforderlich.
Manifest-basiertes selektives Laden: Agenten lesen `manifest.md` und dann `brief.md` und laden nur die spezifischen Dateien, die für die aktuelle Aufgabe (Planung/Implementierung/Artefakt) relevant sind, wodurch die Prompt-Aufblähung minimiert und gleichzeitig kritischer Kontext erhalten bleibt.
Schlanke Agenten-Bootstraps über Plattformen hinweg: Generiert kleine Bootstrap-Dateien (z. B. `AGENTS.md`, `CLAUDE.md`, `GEMINI.md`), die Agenten auf das Manifest verweisen, anstatt große Anweisungsblöcke einzubetten, und unterstützt Codex, Claude Code, Gemini-ähnliche Agenten und die generische Shell-Nutzung.
Deterministische CLI mit geschützter Wartung: Bietet `init/status/check/read/add/enable/forget/compact/migrate`-Befehle; Wartungsoperationen sind Preview-First und strukturerhaltend, mit Budgetprüfungen und sicheren Mutationsplänen vor der Anwendung von Änderungen.
Geltungsbereichsbezogene, opt-in-Speichermodule: Hält optionales Wissen (z. B. `rules/`, `profiles/`, `areas/`, `archive/`) außerhalb des Standardkontexts, bis es explizit durch das Manifest aktiviert wird, was subsystemspezifische Erinnerungen ermöglicht, ohne jede Aufgabe zu verunreinigen.
Datenschutzfreundliches Vergessen und Archivierungssteuerungen: Unterstützt Soft-/Hard-Forget- und Purge-Workflows mit Tombstones und Redaktionsschutz sowie kontrollierte Archivierung (z. B. Archivierung der ältesten Entscheidung), die eine explizite Bestätigung erfordert, um versehentlichen semantischen Verlust zu vermeiden.
Anwendungsfälle von MemoryCustodian
Softwareteams, die langlebige Codebasen pflegen: Erfassen Sie Architektur-Entscheidungen, Einschränkungen und abgelehnte Ansätze, damit neue Agenten-Sitzungen (und neue Ingenieure) frühere Entscheidungen nicht erneut diskutieren müssen, was wiederholtes Debugging und Nacharbeit über Sprints hinweg reduziert.
Regulierte oder Offline-Umgebungen: Einsatz in Finanz-, Gesundheits-, Verteidigungs- oder luftdichten Unternehmensumgebungen, in denen Cloud-Speicherdienste nicht zulässig sind; die nur auf der Standardbibliothek basierende CLI und die lokale Markdown-Speicherung unterstützen vollständig Offline-Workflows.
Interoperabilität von Multi-Agenten/Tools: Standardisieren Sie das Projektgedächtnis über verschiedene Agenten-Hosts (Codex, Claude Code, Gemini-ähnliche Agenten), damit Teams Tools wechseln können, ohne Kontext zu verlieren oder Prompts neu erstellen zu müssen.
Beratung und Agentur-Übergaben: Liefern Sie Kundenprojekte mit einem auditierbaren, im Repository enthaltenen Speicherpaket (Briefing/Entscheidungen/Einschränkungen/nicht verwenden), das die Begründung und Grenzen für zukünftige Betreuer bewahrt.
Komplexe Monorepos und Subsystem-Verantwortlichkeiten: Verwenden Sie `areas/` und Manifest-Routing, um nur domänenrelevante Erinnerungen (Frontend, Synchronisierung, Infrastruktur usw.) zu laden, um Agenten zu helfen, effektiv zu arbeiten, ohne den gesamten Organisationskontext in jede Aufgabe zu ziehen.
Vorteile
Portabel und auditierbar: Der Speicher ist einfaches Markdown im Repository, leicht zu überprüfen, zu diffen und versionszukontrollieren.
Geringer Overhead-Kontext: Manifest-gesteuertes selektives Laden vermeidet Prompt-Aufblähung und hält Agenten-Sitzungen effizient.
Offline-First und minimale Abhängigkeiten: Die Kern-CLI ist nur auf der Python-Standardbibliothek basierend und so konzipiert, dass sie ohne Netzwerkdienste funktioniert.
Nachteile
Erfordert Disziplin bei der Kuration: Das generierte `brief.md`-Gerüst muss aus maßgeblichen Quellen kuratiert werden, bevor es vertrauenswürdig ist.
Kein automatischer semantischer Abruf: Vermeidet absichtlich Embeddings/RAG, daher hängt die Relevanz von einer guten Manifeststruktur und der Schreibqualität von Mensch/Agent ab.
Wartungsoperationen können konservativ sein: Preview-First-Schutzmaßnahmen und Einschränkungen (z. B. Breitband-Schutz) können zusätzliche Workflow-Schritte für Benutzer bedeuten, die eine vollautomatische Bereinigung erwarten.
Wie verwendet man MemoryCustodian
1) MemoryCustodian installieren (wählen Sie den Pfad, der zu Ihrem Agenten/Workflow passt): Wählen Sie eine Installationsmethode:
- Bitten Sie Ihren Codierungsagenten, die Fähigkeit aus dem Repository zu installieren: https://github.com/waittim/MemoryCustodian
- Codex (lokaler Marktplatz): Führen Sie `codex plugin marketplace add .` von einem Checkout aus, dann `codex plugin add memory-custodian@memory-custodian-dev`.
- Claude Code (Plugin): Für lokale Tests führen Sie `claude --plugin-dir .` aus, oder installieren Sie es in persönliche Fähigkeiten mit `./install.sh claude`.
- Gemini-ähnliche Agenten: Installieren Sie mit `./install.sh gemini` oder `gemini skills link ./skills/memory-custodian`.
- CLI/Quell-Checkout: Führen Sie vom Repository aus über `scripts/memory-custodian ...` aus oder installieren Sie editierbar mit `python3 -m pip install -e .`, um den Befehl `memory-custodian` zu erhalten.
2) MemoryCustodian in einem Projekt initialisieren (einmalig pro Repository): Führen Sie die Initialisierung einmal für jedes Zielprojekt aus:
- Wenn als Konsolenskript installiert: `memory-custodian init --project-root /path/to/project --agent all`
- Von einem Quell-Checkout: `scripts/memory-custodian init --project-root /path/to/project --agent all`
Verwenden Sie `--agent codex`, `--agent claude`, `--agent gemini` oder `--agent all`, um die schlanken Bootstrap-Dateien zu generieren, die Ihr Agent liest.
3) Verstehen, was die Initialisierung erstellt (wo der Speicher lebt): Die Initialisierung erstellt den standardmäßigen dauerhaften Speicher unter `docs/memory/`:
- `manifest.md` (steuert, was geladen werden soll)
- `brief.md` (aktuelle Projektform)
- `decisions.md` (Schlüsselentscheidungen)
- `constraints.md` (harte Anforderungen)
- `do-not-use.md` (abgelehnte Pfade / Grabsteine)
- `inbox.md` (Staging-Bereich)
Plattform-Bootstrap-Dateien (z. B. `AGENTS.md`, `CLAUDE.md`, `GEMINI.md`) bleiben schlank und verweisen Agenten auf `docs/memory/`.
4) Den generierten Brief kuratieren, bevor man sich darauf verlässt: Nach `init` beginnt `brief.md` als Gerüst mit TODOs. Füllen Sie es aus maßgeblichen Projektquellen (README, Code, Docs), bevor Sie den Speicher als bereit betrachten. Verwenden Sie `memory-custodian status --project-root /path/to/project` (oder `scripts/memory-custodian status ...`), um zu sehen, ob der Brief noch unkuratiert ist; `status` und `check` melden einen unkuratierten Brief.
5) Den richtigen Speicher für eine Aufgabe laden (Manifest-First-Lesen): Der vorgesehene Workflow für Agenten ist:
1) `docs/memory/manifest.md` lesen.
2) `docs/memory/brief.md` lesen.
3) Nur die vom Manifest als relevant für die aktuelle Aufgabe markierten Dateien laden.
Für die manuelle Inspektion generieren Sie ein Kontextpaket mit:
- `memory-custodian read --project-root /path/to/project --task planning`
- `memory-custodian read --project-root /path/to/project --task implementation`
- `memory-custodian read --project-root /path/to/project --task artifact`
6) Dauerhaften Speicher hinzufügen, wenn etwas den aktuellen Chat überleben soll: Entscheidungen/Einschränkungen/Präferenzen/abgelehnte Ansätze über die CLI aufzeichnen:
- `memory-custodian add "Wir haben das Manifest-First-Laden gewählt." --type decision`
- `memory-custodian add "Persist sync retry backoff." --type decision --area sync --reason "Keep retries bounded across launches."`
Halten Sie Entscheidungseinträge kurz (das Tool erzwingt eine Token-Richtlinie und lehnt überlange Schreibvorgänge ab, es sei denn, Sie erlauben explizit lange Einträge).
7) Optionale Speichermodule nur aktivieren, wenn sie relevant werden: Optionale Module (z. B. Regeln, Profile, Bereiche) sind Opt-in und werden nur geladen, wenn sie aktiviert und vom Manifest geroutet werden. Aktivieren Sie sie bei Bedarf:
- `memory-custodian enable preferences`
- `memory-custodian enable rules/output`
- `memory-custodian enable profile/git`
- `memory-custodian enable area/frontend`
Das Aktivieren überschreibt niemals eine vorhandene Moduldatei.
8) 'do-not-use' verwenden, um abgelehnte Ansätze zu bewahren und Regressionen zu vermeiden: Wenn Sie einen Ansatz absichtlich ablehnen (z. B. ein Speicher-Backend oder eine Architektur), zeichnen Sie ihn in `docs/memory/do-not-use.md` auf (durch Bearbeitungen oder den entsprechenden Add/Forget-Workflow), damit zukünftige Sitzungen ihn nicht erneut vorschlagen.
9) Regelmäßig die Integrität und Protokollkompatibilität überprüfen: Führen Sie eine deterministische Validierung durch, um sicherzustellen, dass Struktur, Budgets und Protokollmetadaten korrekt sind:
- `memory-custodian check --project-root /path/to/project`
Verwenden Sie `memory-custodian status` für einen schnellen Überblick und um einen unkuratierten Brief zu erkennen.
10) Speicher komprimieren und warten (Preview-First, sichere Mutationen): Verwenden Sie Wartungsbefehle, um den Speicher klein und aktuell zu halten:
- `memory-custodian compact --project-root /path/to/project`
Die Komprimierung ist geschützt und Preview-First; wenden Sie Änderungen erst nach Überprüfung des Plans an. Die Inbox-Komprimierung ist konservativ (z. B. exakte Duplikat-Entfernung von Top-Level-Bullet-Units und Tombstone-Filterung) und erwartet, dass ein Agent/Mensch die semantische Promotion in Entscheidungen/Einschränkungen vornimmt.
11) Veraltete Informationen sicher vergessen (Preview-First): Entfernen oder redigieren Sie veraltete Themen mit Preview-First-Vergessen:
- Vorschau: `memory-custodian forget "alte Bereitstellungsnotiz" --mode soft --project-root /path/to/project`
- Nach Überprüfung anwenden: `memory-custodian forget "alte Bereitstellungsnotiz" --mode soft --apply --project-root /path/to/project`
Breite Übereinstimmungen erfordern eine explizite Bestätigung (z. B. `--allow-broad-match`). Einige Fälle erfordern eine manuelle Umschreibung; das Tool wird unsichere pauschale Löschungen ablehnen.
12) Eine bestehende Einrichtung bei Bedarf reparieren oder ersetzen: Wenn Dateien fehlen oder Metadaten aktualisiert werden müssen, ohne kuratierten Inhalt zu überschreiben:
- Reparieren: `memory-custodian init --project-root /path/to/project --repair`
Wenn Sie absichtlich einen vollständigen Ersatz wünschen, verwenden Sie den Preview-First-Ersatz und wenden Sie ihn nur an, wenn er korrekt ist:
- `memory-custodian init --project-root /path/to/project --replace-existing`
- dann fügen Sie `--apply` nur hinzu, wenn die aufgelisteten Dateien ersetzt werden sollen.
13) Protokoll-/Projekt-Speicherversionen migrieren, wenn das Tool aktualisiert wird: Wenn `check` alte oder fehlende Protokollmetadaten meldet, migrieren Sie das Projektmanifest offline:
- Vorschau: `memory-custodian migrate --project-root /path/to/project`
- Nach Überprüfung anwenden: `memory-custodian migrate --apply --project-root /path/to/project`
14) Die richtige Aufrufmethode unter Windows vs. Quell-Checkout verwenden: Unter Windows installieren Sie den Konsolenbefehl und verwenden `memory-custodian ...`. Von einem Repository-Checkout auf jeder Plattform können Sie `scripts/memory-custodian ...` als Wrapper ausführen.
MemoryCustodian FAQs
MemoryCustodian ist ein Tool, das Codierungsagenten ein dauerhaftes „Projektgedächtnis“ verleiht, indem es Entscheidungen, Einschränkungen, verworfene Ideen und Projektkontext als einfaches Markdown in Ihrem Repository speichert und dann nur die für die aktuelle Aufgabe benötigten Teile lädt.
MemoryCustodian Video
Beliebte Artikel

Atoms: Eine Multi-Agenten-KI-Plattform, die Ideen in startbereite Produkte verwandelt
May 22, 2026

Nano Banana SBTI: Was es ist, wie es funktioniert und wie man es im Jahr 2026 einsetzt
Apr 15, 2026

Atoms Review – Der KI-Produkt-Builder, der die digitale Erstellung im Jahr 2026 neu definiert
Apr 10, 2026

Kilo Claw: Wie man einen echten "Do-It-For-You" KI-Agenten bereitstellt und verwendet (2026 Update)
Apr 3, 2026







