> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devin.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Memories & Rules

> Kontext über mehrere Cascade-Unterhaltungen hinweg bewahren – mit automatisch generierten Memories und vom Nutzer definierten Rules auf globaler, Workspace- und Systemebene für Enterprise-Teams.

`Memories` ist das System, mit dem Kontext über Unterhaltungen hinweg geteilt und dauerhaft gespeichert wird.

In Devin Desktop gibt es dafür zwei Mechanismen: **Memories**, die von Cascade automatisch generiert werden, und **Rules**, die vom Nutzer manuell auf globaler, Workspace- oder Systemebene definiert werden.

<div id="memories-rules-workflows-or-skills">
  ## Memories, Rules, Workflows oder Skills?
</div>

Devin Desktop bietet mehrere Möglichkeiten, Cascade anzupassen. Nutze diese Tabelle, um die passende auszuwählen:

| Feature                                        | Was es tut                                                                         | Wie es aktiviert wird                                                                  | Wann du es verwenden solltest                                                                                 |
| ---------------------------------------------- | ---------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- |
| **[Rules](#rules)**                            | Geben Cascade vor, *wie es sich verhalten soll* (z. B. „verwende bun statt npm“)   | `always_on`, `glob`, `model_decision` oder `manual` ([siehe unten](#activation-modes)) | Coding-Conventions, Styleguides, Projektvorgaben                                                              |
| **[AGENTS.md](/de/desktop/cascade/agents-md)** | Regeln mit Verzeichnisbezug, ganz ohne Konfiguration                               | Automatisch — Root = immer aktiv, Unterverzeichnis = glob                              | Verzeichnisspezifische Konventionen ohne frontmatter                                                          |
| **[Workflows](/de/desktop/cascade/workflows)** | Prompt-Vorlagen für wiederkehrende mehrstufige Aufgaben                            | **Nur manuell** über den `/[workflow-name]` Slash Command                              | Deployments, PR-Reviews, Release-Checklisten                                                                  |
| **[Skills](/de/desktop/cascade/skills)**       | Mehrstufige Anleitungen, gebündelt mit unterstützenden Dateien (Skripte, Vorlagen) | Vom Modell dynamisch aufgerufen oder per `@mention`                                    | Komplexe Aufgaben, bei denen Cascade Referenzdateien benötigt — **hier lohnt es sich zu investieren**         |
| **[Memories](#memories)**                      | Kontext, den Cascade in Unterhaltungen automatisch generiert                       | Automatischer Abruf, wenn relevant                                                     | Lass Cascade sich einmalige Fakten merken; für dauerhaftes Wissen solltest du Rules oder AGENTS.md bevorzugen |

<Tip>
  **Empfehlung:** Für Wissen, das Cascade zuverlässig wiederverwenden soll, schreibe es als Rule oder füge es in deinem Repo zu `AGENTS.md` hinzu, statt dich auf automatisch generierte Memories zu verlassen. Rules sind versionskontrolliert, im Team teilbar und geben dir explizite Kontrolle über die Aktivierung.
</Tip>

<div id="how-to-manage-memories">
  ## So verwalten Sie Memory
</div>

Auf Memory und Rules können Sie jederzeit zugreifen und sie konfigurieren, indem Sie in Cascade im Schiebemenü oben rechts auf das Symbol `Customizations` klicken oder unten rechts „Devin - Settings“ auswählen. Um eine vorhandene Memory zu bearbeiten, klicken Sie einfach darauf und dann auf die Schaltfläche `Edit`.

<video autoPlay controls muted loop playsInline className="aspect-video" src="https://mintcdn.com/cognitionai/hxeMffzXgF_RWx-U/desktop/assets/windsurf/cascade/memories-rules.mp4?fit=max&auto=format&n=hxeMffzXgF_RWx-U&q=85&s=f264942bd2e40966555454624f1958b4" data-path="desktop/assets/windsurf/cascade/memories-rules.mp4" />

<div id="memories">
  ## Memory
</div>

Während der Unterhaltung kann Cascade automatisch Memory erstellen und speichern, wenn es auf Kontext stößt, den es für später nützlich hält.

Außerdem kannst du Cascade jederzeit bitten, eine Memory zu erstellen. Gib Cascade dazu einfach den Prompt „Erstelle eine Memory zu ...“.

Die von Cascade automatisch erstellten Memory sind dem Workspace zugeordnet, in dem sie erstellt wurden, und werden lokal in `~/.codeium/windsurf/memories/` gespeichert. Cascade ruft sie ab, wenn es sie für relevant hält. Memory, die in einem Workspace erstellt wurden, sind in einem anderen nicht verfügbar und werden nicht in deinem Repository committet.

<Tip>Das Erstellen und Verwenden automatisch generierter Memory verbraucht KEINE Credits.</Tip>

<Note>
  Automatisch generierte Memory existieren nur auf deinem Rechner. Wenn du möchtest, dass Cascade sich dauerhaft an etwas erinnert — und es mit deinem Team teilt — bitte Cascade stattdessen, es in eine [Rule](#rules) in `.devin/rules/` (oder das legacy `.windsurf/rules/`) oder in die `AGENTS.md` deines Repo zu schreiben.
</Note>

<div id="rules">
  ## Rules
</div>

Nutzer können eigene Rules explizit definieren, denen Cascade folgen soll.

Rules können auf globaler, Workspace- oder Systemebene definiert und auch aus [AGENTS.md](/de/desktop/cascade/agents-md)-Dateien abgeleitet werden.

| Geltungsbereich                                       | Speicherort                                                                         | Hinweise                                                                                                                                                                                                                        |
| ----------------------------------------------------- | ----------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Global                                                | `~/.codeium/windsurf/memories/global_rules.md`                                      | Einzelne Datei, die für alle Workspaces gilt. Immer aktiv. Auf 6.000 Zeichen begrenzt.                                                                                                                                          |
| Workspace                                             | `.devin/rules/*.md` (bevorzugt) oder `.windsurf/rules/*.md` (Fallback)              | Eine Datei pro Rule, jeweils mit eigenem [Aktivierungsmodus](#activation-modes). Auf 12.000 Zeichen pro Datei begrenzt. Die Legacy-Einzeldatei `.windsurfrules` im Workspace-Stammverzeichnis wird ebenfalls weiterhin gelesen. |
| [AGENTS.md](/de/desktop/cascade/agents-md)            | Beliebiges Verzeichnis in Ihrem Workspace                                           | Wird von derselben Rules-Engine verarbeitet — auf Root-Ebene = immer aktiv, in Unterverzeichnissen = automatisches Glob für dieses Verzeichnis.                                                                                 |
| [System (Enterprise)](#system-level-rules-enterprise) | Betriebssystemspezifisch (z. B. `/etc/devin/rules/`, Legacy `/etc/windsurf/rules/`) | Wird von der IT bereitgestellt, für Endnutzer schreibgeschützt.                                                                                                                                                                 |

<div id="rules-discovery">
  ## Auffinden von Rules
</div>

Devin Desktop findet Rules automatisch an mehreren Speicherorten, um eine flexible Organisation zu ermöglichen. Das Verzeichnis `.devin/` ist der bevorzugte Speicherort und hat Vorrang, wobei `.windsurf/` aus Gründen der Abwärtskompatibilität als Fallback beibehalten wird:

* **Aktueller Workspace und Unterverzeichnisse**: Alle `.devin/rules`-Verzeichnisse (und veralteten `.windsurf/rules`-Verzeichnisse) in Ihrem aktuellen Workspace und dessen Unterverzeichnissen
* **Git-Repository-Struktur**: In Git-Repositories sucht Devin Desktop außerdem bis zum Git-Root-Verzeichnis nach oben, um Rules in übergeordneten Verzeichnissen zu finden
* **Unterstützung für mehrere Workspaces**: Wenn mehrere Ordner im selben Workspace geöffnet sind, werden Rules dedupliziert und mit dem kürzesten relativen Pfad angezeigt

<div id="rules-storage-locations">
  ### Speicherorte für Rules
</div>

Rules können an jedem dieser Orte gespeichert werden (`.devin/` wird bevorzugt und hat Vorrang vor `.windsurf/`):

* `.devin/rules` oder `.windsurf/rules` im Verzeichnis Ihres aktuellen Workspace
* `.devin/rules` oder `.windsurf/rules` in einem beliebigen Unterverzeichnis Ihres Workspace
* `.devin/rules` oder `.windsurf/rules` in übergeordneten Verzeichnissen bis zum Git-Root (für Git-Repositories)

Wenn Sie eine neue Regel erstellen, wird sie im Verzeichnis `.devin/rules` Ihres aktuellen Workspace gespeichert, nicht unbedingt am Git-Root.

Um mit Rules zu beginnen, klicken Sie im Ausklappmenü oben rechts in Cascade auf das Symbol `Customizations` und wechseln Sie dann zum Bereich `Rules`. Dort können Sie auf die Schaltfläche `+ Global` oder `+ Workspace` klicken, um jeweils neue Rules auf globaler Ebene oder auf Workspace-Ebene zu erstellen.

<Tip>Beispielvorlagen für Rules, zusammengestellt vom Devin-Desktop-Team, finden Sie unter [https://windsurf.com/editor/directory](https://windsurf.com/editor/directory), um den Einstieg zu erleichtern.</Tip>

Workspace-Regeldateien sind jeweils auf 12.000 Zeichen begrenzt. Die globale Rules-Datei ist auf 6.000 Zeichen begrenzt.

<div id="activation-modes">
  ### Aktivierungsmodi
</div>

Jede Workspace-Regel deklariert in ihrem Frontmatter über das Feld `trigger` einen Aktivierungsmodus. Dieser legt fest, **wann** der Inhalt der Regel an Cascade übergeben wird und **wie viel Platz im Kontextfenster er belegt**:

| Modus                  | `trigger:`-Wert  | Wie die Regel zu Cascade gelangt                                                                                                                           | Kontextkosten                                       |
| ---------------------- | ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------- |
| **Immer aktiv**        | `always_on`      | Der vollständige Regelinhalt wird bei jeder Nachricht in den System-Prompt aufgenommen.                                                                    | Jede Nachricht                                      |
| **Modellentscheidung** | `model_decision` | Im System-Prompt wird nur die `description` angezeigt. Cascade liest die vollständige Regeldatei, wenn es entscheidet, dass die Beschreibung relevant ist. | Beschreibung immer; vollständiger Inhalt bei Bedarf |
| **Glob**               | `glob`           | Die Regel wird angewendet, wenn Cascade eine Datei liest oder bearbeitet, die dem `globs`-Muster entspricht (z. B. `*.js`, `src/**/*.ts`).                 | Nur wenn passende Dateien betroffen sind            |
| **Manuell**            | `manual`         | Die Regel ist **nicht** im System-Prompt enthalten. Sie wird aktiviert, indem `@rule-name` in das Cascade-Eingabefeld eingegeben wird.                     | Nur bei @Erwähnung                                  |

<Note>
  Die globale Regeldatei (`global_rules.md`) und `AGENTS.md`-Dateien auf Root-Ebene verwenden kein Frontmatter — sie sind immer aktiv.
</Note>

Beispiel für eine Workspace-Regel mit Frontmatter:

```markdown theme={null}
---
trigger: glob
globs: **/*.test.ts
---

All test files must use `describe`/`it` blocks and mock external API calls.
```

<div id="best-practices">
  ### Bewährte Vorgehensweisen
</div>

Damit Cascade Ihre Regeln zuverlässig befolgt, beachten Sie diese Best Practices:

* Halten Sie Regeln einfach, prägnant und spezifisch. Zu lange oder zu vage Regeln können Cascade verwirren.
* Es ist nicht nötig, allgemeine Regeln hinzuzufügen (z. B. "guten Code schreiben"), da diese bereits in Cascades Trainingsdaten enthalten sind.
* Formatieren Sie Ihre Regeln mit Aufzählungspunkten, nummerierten Listen und Markdown. Diese kann Cascade leichter befolgen als einen langen Absatz. Zum Beispiel:

```
# Coding Guidelines 
- My project's programming language is python
- Use early returns when possible
- Always add documentation when creating new functions and classes
```

* XML-Tags können eine effektive Möglichkeit sein, ähnliche Regeln zu kommunizieren und zusammenzufassen. Zum Beispiel:

```
<coding_guidelines>
- My project's programming language is python
- Use early returns when possible
- Always add documentation when creating new functions and classes
</coding_guidelines>
```

<div id="system-level-rules-enterprise">
  ## Rules auf Systemebene (Enterprise)
</div>

Enterprise-Organisationen können Rules auf Systemebene festlegen, die global für alle Workspaces gelten und von Nutzern ohne Administratorberechtigungen nicht geändert werden können. Das ist ideal, um organisationsweite Programmierstandards, Sicherheitsrichtlinien und Compliance-Anforderungen durchzusetzen.

Rules auf Systemebene werden aus betriebssystemspezifischen Verzeichnissen geladen. Das Verzeichnis `Devin` wird bevorzugt und hat Vorrang, während das Legacy-Verzeichnis `Windsurf` als Fallback beibehalten wird:

**macOS:**

```
/Library/Application Support/Devin/rules/*.md
/Library/Application Support/Windsurf/rules/*.md   # legacy fallback
```

**Linux/WSL:**

```
/etc/devin/rules/*.md
/etc/windsurf/rules/*.md   # legacy Fallback
```

**Windows:**

```
C:\ProgramData\Devin\rules\*.md
C:\ProgramData\Windsurf\rules\*.md   # legacy Fallback
```

Legen Sie Ihre Regeldateien (als `.md`-Dateien) im passenden Verzeichnis für Ihr Betriebssystem ab. Das System lädt automatisch alle `.md`-Dateien aus diesen Verzeichnissen.

<div id="how-system-rules-work">
  ### Wie Regeln auf Systemebene funktionieren
</div>

Regeln auf Systemebene werden mit Workspace- und globalen Regeln zusammengeführt und liefern Cascade zusätzlichen Kontext, ohne von Nutzern definierte Regeln zu überschreiben. Dadurch können Organisationen grundlegende Standards festlegen und Teams gleichzeitig projektspezifische Anpassungen hinzufügen.

In der Devin Desktop UI werden Regeln auf Systemebene mit dem Label „System“ angezeigt und können von Endnutzern nicht gelöscht werden.

<Note>
  **Wichtig**: Regeln auf Systemebene sollten von Ihrem IT- oder Sicherheitsteam verwaltet werden. Stellen Sie sicher, dass Ihre internen Teams Bereitstellung, Aktualisierungen und die Einhaltung von Richtlinien gemäß den Vorgaben Ihrer Organisation übernehmen. Dazu können Sie Standard-Tools und -Workflows wie Mobile Device Management (MDM) oder Configuration Management verwenden.
</Note>