# Shared Memory für KI-Coding-Agenten: ein Projekt-Brain

URL: https://agentvera.dev/de/blog/shared-memory-for-ai-coding-agents/ · Veröffentlicht: 2026-10-24

Shared Memory für KI-Coding-Agenten: Wie ein Projekt-Brain Entscheidungen, Übergabenotizen und Korrekturen bewahrt, damit jede neue Sitzung informiert startet.

**Kurz gesagt:**

- Jede neue Agenten-Sitzung startet leer. Ein gemeinsames Projektgedächtnis bewahrt Entscheidungen, Korrekturen und Übergabenotizen, damit der nächste Agent alte Fehler nicht wiederholt.
- Das Brain von AgentVera baut dieses Gedächtnis aus deinen Docs, Commits, PRs, Issues und früheren Agenten-Unterhaltungen auf und markiert jede Entscheidung als current, stale oder superseded.
- Agenten lesen und schreiben es über MCP: brain_recall durchsucht das Gedächtnis, brain_remember behält eine Korrektur oder Entscheidung, kurze Übergabenotizen entstehen nach Turns und beim Compacten.

**Shared Memory für KI-Coding-Agenten ist ein Speicher auf Projektebene für Entscheidungen, Korrekturen und Übergabenotizen, den jeder Agent zu Beginn liest und bei der Arbeit ergänzt, sodass eine neue Sitzung nicht bei null anfängt.** Ohne ihn kennt jede Claude-Code- oder Codex-Sitzung nur das, was im Repo und in ihren Anweisungsdateien steht. Mit ihm weiß der nächste Agent, warum du dich für JWT entschieden hast, dass der Nutzer schon „keine neuen Abhängigkeiten“ gesagt hat und dass der letzte Agent den Erstattungs-Ablauf halb fertig hinterlassen hat.

Dieser Beitrag erklärt, warum Agenten vergessen, was in ein Shared Memory gehört und wie das Brain von AgentVera eines aus deiner Projekthistorie aufbaut und Agenten es über MCP lesen und schreiben lässt.

## Warum Coding-Agenten vergessen

Das Gedächtnis eines Coding-Agenten ist sein Kontextfenster. Endet die Sitzung oder wird die Unterhaltung compactet, ist das meiste von dem, was passiert ist, weg. Die nächste Sitzung bekommt:

- Den System-Prompt und die Tool-Definitionen
- Deine Anweisungsdateien, etwa `CLAUDE.md` oder `AGENTS.md`
- Alles, was sie während der Aufgabe aus dem Repo liest

Für Code funktioniert das, weil der Code im Repo liegt. Bei Begründungen scheitert es. Der Commit sagt, *was* sich geändert hat; der Grund steht oft in einem PR-Kommentar, einem Issue oder einer Unterhaltung mit einem Agenten, den es nicht mehr gibt. Also stellen Agenten dieselben Fragen, schlagen den Ansatz vor, den du letzte Woche abgelehnt hast, und erledigen Arbeit doppelt, die ein anderer Agent schon fertig hatte. Wenn du [mehrere Agenten parallel ausführst](/de/blog/run-multiple-claude-code-agents/ "Mehrere Claude Code Agenten ausführen"), wird das schlimmer: Jeder lernt etwas, das die anderen nie sehen.

## Was in ein Shared Memory gehört

Anweisungsdateien und ein Shared Memory erfüllen unterschiedliche Aufgaben.

| | Anweisungsdatei (CLAUDE.md, AGENTS.md) | Shared Memory |
| --- | --- | --- |
| Geschrieben von | Dir, von Hand | Aus der Historie aufgebaut, plus Agenten bei der Arbeit |
| Inhalt | Regeln, Befehle, Konventionen | Entscheidungen mit Begründung, Korrekturen, Übergabenotizen |
| Änderungen | Selten | Jeden Tag |
| Geladen | Ganze Datei, jede Sitzung | Bei Bedarf durchsucht, kurze Zusammenfassung zum Start |
| Weiß, wann sie veraltet ist | Nein | Kann Entscheidungen als stale oder superseded markieren |

Halte deine Anweisungsdatei kurz und stabil ([so schreibst du eine](/de/blog/claude-md-agents-md/ "CLAUDE.md und AGENTS.md")). Lege das, was sich bewegt, ins Gedächtnis. Ein nützliches Shared Memory enthält vier Arten von Dingen:

1. **Entscheidungen.** „Wir nutzen JWT für die API, weil Sessions die mobile App kaputt gemacht haben“, mit Datum und Quelle.
2. **Korrekturen.** Dinge, bei denen der Nutzer einem Agenten gesagt hat, dass er falschlag. Sie zu verlieren ist am teuersten.
3. **Übergabenotizen.** Was ein Agent getan hat und was er offengelassen hat.
4. **Fakten.** Kleine Wahrheiten über das Projekt, die aus dem Code nicht offensichtlich sind.

## Wie das Brain von AgentVera das Gedächtnis aufbaut

In AgentVera hat jedes Projekt auf seiner Details-Seite einen Tab **Brain**. Klick auf **Build memory** (später **Refresh memory**), und es liest die Historie des Projekts:

- Von Git verfolgte Docs und Entscheidungsprotokolle: README, ARCHITECTURE, CONTRIBUTING, CLAUDE, AGENTS, CHANGELOG, `docs/`, `adr/` und `decisions/` (bis zu 250 Dateien)
- Die neuesten 1.500 Commits ohne Merges
- Bis zu 200 Pull Requests und 200 Issues, wenn das Projekt auf GitHub liegt und du angemeldet bist
- Bis zu 120 frühere Agenten-Unterhaltungen

Claude Haiku zieht aus diesem Material die Entscheidungen heraus. Jede bekommt einen Titel, die Begründung, ein Datum, ihre Quellen und die Code-Begriffe, um die es geht. Duplikate werden zusammengeführt.

Entscheidungen gelten nicht ewig, deshalb hat jede einen Status: **current**, **stale** oder **superseded**. **Compare with code** gleicht die Code-Begriffe einer Entscheidung per `git grep` mit dem Repo ab. **Verify with Claude** führt für einen genaueren Blick eine schreibgeschützte Prüfung mit Sonnet aus. So kann das Gedächtnis einem Agenten sagen: „Das haben wir entschieden, aber der Code ist weitergezogen.“

Der Tab Brain hat vier Ansichten: **Decisions**, **Knowledge graph**, **Context pack** und **Memory**. Dazu gibt es ein Feld **Ask**. Frag „Why do we use JWT?“, und Sonnet antwortet schreibgeschützt aus dem Gedächtnis, mit Verweisen auf die Quellen.

## Wie Agenten das Gedächtnis lesen und schreiben

Das Gedächtnis aufzubauen ist die halbe Arbeit. Die andere Hälfte ist, Agenten dazu zu bringen, es zu nutzen. AgentVera fügt jedem Agenten, dessen CLI MCP-Server unterstützt, einen MCP-Server namens `agentvera-brain` hinzu. Wenn MCP neu für dich ist, fang mit [was ein MCP-Server ist](/de/blog/what-is-mcp-server/ "Was ist ein MCP-Server?") an.

Der Server hat zwei Tools:

| Tool | Was es tut |
| --- | --- |
| `brain_recall` | Durchsucht Entscheidungen (mit Status), Docs, Commits, PRs, Issues, frühere Unterhaltungen, Übergabenotizen und gemerkte Fakten. Liefert bis zu 8 Treffer, jeder mit einer `[id]` zum Zitieren. Ohne Suchanfrage aufgerufen, liefert es die behaltenen Erinnerungen und offenen Fäden. |
| `brain_remember` | Behält einen in sich geschlossenen Satz als `fact`, `correction` oder `decision`. Nicht für Fortschrittsmeldungen gedacht. Identischer Text wird nicht doppelt gespeichert. |

Der Server sagt dem Agenten auch, wann er sie nutzen soll: `brain_recall` vor einer Aufgabe aufrufen, die frühere Arbeit berührt, `brain_remember` aufrufen, wenn der Nutzer ihn korrigiert, eine Regel oder Präferenz nennt oder eine Entscheidung fällt, und Einträge mit `[id]` zitieren.

Ein typischer Austausch in einer Claude-Code-Sitzung sieht so aus:

```text
You: Add refresh tokens to the API.
Agent: (calls brain_recall "auth tokens JWT")
       Found [d12] "Use JWT for the API, sessions broke the mobile app" (current)
       and a correction [m4] "Never store tokens in localStorage".
       I will keep JWT and put the refresh token in an httpOnly cookie.
You: Good. And refresh tokens expire after 30 days.
Agent: (calls brain_remember, kind: decision)
```

Der nächste Agent, der Auth anfasst, findet beides, ohne dass du dich wiederholen musst.

## Übergabenotizen: Gedächtnis zwischen Sitzungen

Der Schalter **Agents write the memory** im Tab Brain ist an, solange du ihn nicht ausschaltest. Ist er an:

- Nach Turns (höchstens alle 15 Minuten pro Agent) und immer, wenn ein Agent seine Unterhaltung compactet, hinterlässt der Agent eine kurze Übergabenotiz. Haiku schreibt sie: eine Zusammenfassung aus ein bis vier Sätzen und bis zu sechs offene Fäden, angezeigt als **Left open**.
- Korrekturen und Entscheidungen, die der Agent mit `brain_remember` behält, landen im selben Gedächtnis.
- Neue Agenten des Projekts bekommen die jüngsten davon.
- Zwischen 03:00 und 06:00 wird das Brain neu kompiliert, aber nur, wenn es schon einmal aufgebaut wurde, seitdem neue Notizen da sind und höchstens alle 12 Stunden.

Notizen und Erinnerungen stehen in der Ansicht **Memory**, gekennzeichnet als Fact, Correction, Decision oder Session note. **Forget** entfernt eine.

Wenn ein neuer Agent startet, bekommen seine Anweisungen eine kurze Einführung von bis zu 2.500 Zeichen: die behaltenen Erinnerungen (Korrekturen zuerst, bis zu 15) sowie die neueste Notiz von bis zu sechs anderen Agenten der letzten sieben Tage, die noch offene Fäden haben. Das macht das Compacten weniger schmerzhaft: Die Zusammenfassung, die Claude Code schreibt, ist nach der Sitzung weg, die Übergabenotiz bleibt. Mehr dazu, was das Compacten behält und verwirft, steht in [Kontextfenster von Claude Code](/de/blog/claude-code-context-window/ "Kontextfenster von Claude Code").

## Das Context pack

Getrennt davon enthält die Ansicht **Context pack** eine Zusammenfassung des Projekts von bis zu 2.500 Zeichen. Schalte **Give new agents a context pack** ein, dann bekommen neue Agenten das Pack plus die Liste veralteter Entscheidungen in ihren Anweisungen. Es ist standardmäßig aus, weil es den Startkontext jedes neuen Agenten vergrößert. Schalte es ein, wenn deine Agenten immer wieder dasselbe Hintergrundwissen verpassen.

## In fünf Schritten einrichten

1. Öffne das Projekt in AgentVera und geh zu **Details → Brain**.
2. Klick auf **Build memory**. Melde dich zuerst bei GitHub an, wenn PRs und Issues einbezogen werden sollen.
3. Sieh dir **Decisions** an. Führe **Compare with code** bei den Entscheidungen aus, an denen du zweifelst.
4. Lass **Agents write the memory** eingeschaltet und entscheide, ob du das Context pack willst.
5. Starte einen neuen Claude-Code- oder Codex-Agenten und gib ihm eine Aufgabe, die frühere Arbeit berührt. Sieh zu, wie er `brain_recall` aufruft.

## Shared Memory und Koordination

Das Gedächtnis beantwortet „Was wissen wir?“. Koordination beantwortet „Wer macht gerade was?“. Für laufende Arbeit gibt AgentVera Agenten außerdem ein Schwarzes Brett über MCP (`agentvera-board`), auf dem sie Notizen, Entscheidungen, Todos und Erkenntnisse posten, und es warnt, wenn zwei Agenten dieselbe Datei bearbeiten. Beides passt zusammen: Das Board ist für heute, das Brain für nächsten Monat.

Das Gedächtnis passt auch gut zur [Projektkarte](/de/features/project-map/ "Projektkarte"). Die Karte sagt einem Agenten, *wo* Code liegt; das Brain sagt ihm, *warum* der Code so ist.

## Grenzen, die du kennen solltest

- Das Brain wird Agenten hinzugefügt, die MCP-Server unterstützen. Einfache Terminals und Agenten auf einem entfernten SSH-Host bekommen es nicht.
- Sitzungsnotizen und Erinnerungen behalten jeweils bis zu 200 Einträge.
- Alles wird lokal gespeichert, eine Datei pro Projekt im Datenordner der App. Entscheidungs-Extraktion, Übergabenotizen und Antworten nutzen Claude über deine Claude-Code-Anmeldung, diese Anfragen gehen also an Anthropic.
- Ein Gedächtnis ist nur so gut wie das, was es behält. Sieh dir die Ansicht Memory ab und zu an und vergiss Notizen, die falsch sind.

## Zusammenfassung

Shared Memory für KI-Coding-Agenten füllt die Lücke zwischen statischen Anweisungsdateien und einem Kontextfenster, das zurückgesetzt wird. Das Brain von AgentVera baut es aus deinen Docs, Commits, PRs, Issues und Unterhaltungen auf, verfolgt, welche Entscheidungen noch gelten, und lässt jeden MCP-fähigen Agenten über `agentvera-brain` abrufen und merken, mit Übergabenotizen nach Turns und beim Compacten. Das Brain gehört zum kostenlosen Plan. Lies die [Brain-Funktionsseite](/de/features/brain/ "Brain") oder [lade AgentVera herunter](/de/download/) und baue das Gedächtnis deines ersten Projekts auf.

## Häufige Fragen

**Was ist Shared Memory für KI-Coding-Agenten?** Ein Speicher für Projektwissen, den jeder Agent lesen und ergänzen kann: warum Entscheidungen getroffen wurden, was der Nutzer korrigiert hat, was ein früherer Agent offengelassen hat. Er überlebt eine einzelne Sitzung, sodass ein neuer Agent mit dem Kontext startet, den der letzte hatte.

**Reicht CLAUDE.md nicht aus?** CLAUDE.md und AGENTS.md enthalten Regeln, die du von Hand schreibst und die sich selten ändern. Ein Shared Memory enthält auch, was während der Arbeit passiert: Entscheidungen aus Commits und PRs, Korrekturen, Übergabenotizen und welchen Entscheidungen der Code nicht mehr folgt.

**Wie nutzen Agenten das Brain in AgentVera?** Über einen MCP-Server namens agentvera-brain. brain_recall durchsucht Entscheidungen, Docs, Commits, PRs, Issues, frühere Unterhaltungen und Notizen; brain_remember behält einen Satz als Fakt, Korrektur oder Entscheidung. Agenten sollen zitieren, was sie nutzen, mit der [id].

**Welche Agenten bekommen das Shared Memory?** Agenten, deren CLI MCP-Server unterstützt, etwa Claude Code und Codex. Einfache Terminals und Agenten auf einem entfernten SSH-Host bekommen es nicht.

**Wo wird das Gedächtnis gespeichert?** Auf deinem Rechner, eine Datei pro Projekt im Datenordner der App. Das Extrahieren von Entscheidungen und das Beantworten von Fragen nutzt Claude über deine Claude-Code-Anmeldung, diese Anfragen gehen also an Anthropic.

---

**Über AgentVera.** AgentVera ist eine Desktop-App für macOS, Windows und Linux, entwickelt von Solviera Teknoloji. Sie führt 18 KI-Coding-Agenten (Claude Code, Codex, Gemini CLI, Copilot, Cursor, Antigravity, opencode, Hermes, Qwen Code, Kimi Code, Kiro, Amp, Droid, Goose, Vibe, Crush, Aider, Cline) nebeneinander aus, pro Projekt, in echten Terminals mit den eigenen CLI-Installationen und Logins des Nutzers. Der kostenlose Plan hat unbegrenzt viele Agenten. Download: https://agentvera.dev/de/download/ · Preise: https://agentvera.dev/de/pricing/