---
title: Skills für Unternehmen
url: https://platform.claude.com/docs/de/agents-and-tools/agent-skills/enterprise
description: Governance, Sicherheitsprüfung, Evaluierung und organisatorische Leitlinien für die Bereitstellung von Agent Skills im Unternehmensmaßstab.
---

Dieser Leitfaden richtet sich an Enterprise-Administratoren und -Architekten, die Agent Skills in einer gesamten Organisation steuern müssen. Er behandelt, wie du Skills im großen Maßstab prüfst, evaluierst, bereitstellst und verwaltest. Anleitungen zum Erstellen findest du unter [Best Practices für das Erstellen von Skills](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/best-practices). Details zur Architektur findest du unter [Agent Skills](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/overview).

## Sicherheitsprüfung und Vetting

Die Bereitstellung von Skills in einem Unternehmen erfordert die Beantwortung zweier unterschiedlicher Fragen:

1. **Sind Skills grundsätzlich sicher?** Siehe den Abschnitt [Sicherheitsüberlegungen](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/overview#security-considerations) in der Übersicht für Sicherheitsdetails auf Plattformebene.
2. **Wie prüfe ich einen bestimmten Skill?** Verwende die folgende Risikobewertung und Prüf-Checkliste.

### Bewertung der Risikostufe

Bewerte jeden Skill anhand dieser Risikoindikatoren, bevor du die Bereitstellung genehmigst:

| Risikoindikator                | Worauf zu achten ist                                                                                                    | Bedenklichkeitsgrad                                                            |
| ------------------------------ | ----------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------ |
| Codeausführung                 | Skripte im Skill-Verzeichnis (`*.py`, `*.sh`, `*.js`)                                                                   | Hoch: Skripte laufen mit vollem Umgebungszugriff                               |
| Manipulation von Anweisungen   | Direktiven, Sicherheitsregeln zu ignorieren, Aktionen vor Nutzern zu verbergen oder Claudes Verhalten bedingt zu ändern | Hoch: kann Sicherheitskontrollen umgehen                                       |
| MCP-Server-Referenzen          | Anweisungen, die auf MCP-Tools verweisen (`ServerName:tool_name`)                                                       | Hoch: erweitert den Zugriff über den Skill selbst hinaus                       |
| Netzwerkzugriffsmuster         | URLs, API-Endpunkte, `fetch`-, `curl`- oder `requests`-Aufrufe                                                          | Hoch: potenzieller Vektor für Datenexfiltration                                |
| Hartcodierte Zugangsdaten      | API-Keys, Token oder Passwörter in Skill-Dateien oder Skripten                                                          | Hoch: Geheimnisse werden in der Git-Historie und im Kontextfenster offengelegt |
| Umfang des Dateisystemzugriffs | Pfade außerhalb des Skill-Verzeichnisses, breite Glob-Muster, Path Traversal (`../`)                                    | Mittel: könnte auf unbeabsichtigte Daten zugreifen                             |
| Tool-Aufrufe                   | Anweisungen, die Claude anweisen, Bash, Dateioperationen oder andere Tools zu verwenden                                 | Mittel: prüfe, welche Operationen ausgeführt werden                            |

### Prüf-Checkliste

Bevor du einen Skill von einem Drittanbieter oder internen Mitwirkenden bereitstellst, führe diese Schritte durch:

1. **Lies den gesamten Inhalt des Skill-Verzeichnisses.** Prüfe `SKILL.md`, alle referenzierten Markdown-Dateien sowie alle mitgelieferten Skripte oder Ressourcen.
2. **Verifiziere, dass das Skriptverhalten dem angegebenen Zweck entspricht.** Führe Skripte in einer Sandbox-Umgebung aus und bestätige, dass die Ausgaben mit der Beschreibung des Skills übereinstimmen.
3. **Prüfe auf adversarielle Anweisungen.** Suche nach Direktiven, die Claude anweisen, Sicherheitsregeln zu ignorieren, Aktionen vor Nutzern zu verbergen, Daten über Antworten zu exfiltrieren oder das Verhalten basierend auf bestimmten Eingaben zu ändern.
4. **Prüfe auf externe URL-Abrufe oder Netzwerkaufrufe.** Durchsuche Skripte und Anweisungen nach Netzwerkzugriffsmustern (`http`, `requests.get`, `urllib`, `curl`, `fetch`).
5. **Verifiziere, dass keine hartcodierten Zugangsdaten vorhanden sind.** Prüfe auf API-Keys, Token oder Passwörter in Skill-Dateien. Zugangsdaten sollten Umgebungsvariablen oder sichere Credential-Stores verwenden und niemals im Skill-Inhalt erscheinen.
6. **Identifiziere Tools und Befehle, die Claude laut Skill ausführen soll.** Liste alle Bash-Befehle, Dateioperationen und Tool-Verweise auf. Berücksichtige das kombinierte Risiko, wenn ein Skill sowohl Dateilese- als auch Netzwerk-Tools zusammen verwendet.
7. **Bestätige Weiterleitungsziele.** Wenn der Skill auf externe URLs verweist, verifiziere, dass sie auf erwartete Domains zeigen.
8. **Verifiziere, dass keine Datenexfiltrationsmuster vorhanden sind.** Suche nach Anweisungen, die sensible Daten lesen und sie dann für die externe Übertragung schreiben, senden oder kodieren, auch über Claudes Gesprächsantworten.

<Warning>
  Stelle niemals Skills aus nicht vertrauenswürdigen Quellen ohne vollständiges Audit bereit. Ein bösartiger Skill kann Claude anweisen, beliebigen Code auszuführen, auf sensible Dateien zuzugreifen oder Daten nach außen zu übertragen. Behandle die Installation von Skills mit derselben Sorgfalt wie die Installation von Software auf Produktionssystemen.
</Warning>

### Scannen von Skill-Inhalten

Claude Enterprise-Organisationen können das automatisierte Sicherheitsscanning für benutzerdefinierte Skills in claude.ai und Claude Cowork aktivieren. Die Einstellung heißt **Sicherheitsscan für Skills und Plugins** und befindet sich unter [claude.ai > Organisationseinstellungen > Skills](https://claude.ai/admin-settings/skills).

Nachdem du die Einstellung aktiviert hast, gilt das Scanning für Skills, die Mitglieder anschließend in claude.ai oder Cowork hochladen oder bearbeiten. Jeder Scan prüft auf Anzeichen für bösartiges Verhalten. Zu diesen Anzeichen gehören versteckte Codeausführung, die Übertragung deiner Daten an einen externen Dienst und Anweisungen, die Claudes Schutzmechanismen manipulieren.

Ob ein Skill nutzbar ist, hängt von seinem Scan ab:

* Ein Skill, der den Scan nicht besteht, wird für die Nutzung gesperrt.
* Ein Skill, dessen Scan noch nicht abgeschlossen ist, wird für die Nutzung gesperrt.
* Ein Skill, der mit einer Warnung besteht, bleibt hinter einem Warnhinweis nutzbar.

Organisationsinhaber können einige Skills zulassen, die den Scan nicht bestanden haben. Das können auch Mitglieder, deren [benutzerdefinierte Rolle](https://platform.claude.com/docs/de/manage-claude/user-management#custom-roles) **Bibliotheken** verwalten kann.

Wenn das Scanning für deine Organisation verfügbar ist, aktiviere es. Das Scanning ergänzt die [Prüfcheckliste](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/enterprise#review-checklist), ersetzt sie aber nicht.

Das Scanning deckt die Claude API nicht ab. Skills, die du über die Skills API (`/v1/skills`) hochlädst, auch aus der Claude Console, werden nicht gescannt. Verlasse dich daher bei API-Bereitstellungen auf die Prüf-Checkliste und [Version-Pinning](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/enterprise#versioning-strategy). Das Scanning gilt außerdem nicht für Skills, die sich bereits in deiner Organisation befanden, als du es aktiviert hast, oder für Organisationen mit bestimmten Datenverarbeitungskonfigurationen, etwa kundenverwalteten Verschlüsselungsschlüsseln (CMEK), Zero Data Retention (ZDR) oder HIPAA-Readiness. Einrichtungsschritte, Ausschlüsse und Ergebnistypen findest du unter [Erste Schritte mit Skill- und Plugin-Scanning](https://support.claude.com/en/articles/15927065-get-started-with-skill-and-plugin-scanning) im Claude Hilfe-Center.

## Skills vor der Bereitstellung evaluieren

Skills können die Agentenleistung verschlechtern, wenn sie falsch ausgelöst werden, mit anderen Skills in Konflikt stehen oder schlechte Anweisungen liefern. Verlange eine Evaluierung vor jeder Produktionsbereitstellung.

### Was zu evaluieren ist

Richte Genehmigungsschranken für diese Dimensionen ein, bevor du einen Skill bereitstellst:

| Dimension                | Was sie misst                                                                                | Beispiel für ein Versagen                                                                                     |
| ------------------------ | -------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- |
| Auslösegenauigkeit       | Wird der Skill bei den richtigen Anfragen aktiviert und bleibt bei nicht verwandten inaktiv? | Skill wird bei jeder Erwähnung einer Tabelle ausgelöst, selbst wenn der Nutzer nur über Daten sprechen möchte |
| Isolationsverhalten      | Funktioniert der Skill für sich allein korrekt?                                              | Skill verweist auf Dateien, die in seinem Verzeichnis nicht existieren                                        |
| Koexistenz               | Verschlechtert das Hinzufügen dieses Skills andere Skills?                                   | Die Beschreibung des neuen Skills ist zu breit und stiehlt bestehenden Skills die Auslöser                    |
| Befolgen von Anweisungen | Befolgt Claude die Anweisungen des Skills genau?                                             | Claude überspringt Validierungsschritte oder verwendet falsche Bibliotheken                                   |
| Ausgabequalität          | Liefert der Skill korrekte, nützliche Ergebnisse?                                            | Generierte Berichte haben Formatierungsfehler oder fehlende Daten                                             |

### Evaluierungsanforderungen

Verlange von Skill-Autoren, Evaluierungssuiten mit 3–5 repräsentativen Anfragen für jeden Skill einzureichen, die Fälle abdecken, in denen der Skill ausgelöst werden sollte, Fälle, in denen er nicht ausgelöst werden sollte, sowie mehrdeutige Grenzfälle. Verlange Tests mit allen Modellen, die deine Organisation verwendet (Haiku, Sonnet, Opus), da die Wirksamkeit von Skills je nach Modell variiert.

Detaillierte Anleitungen zum Erstellen von Evaluierungen findest du unter [Evaluierung und Iteration](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/best-practices#evaluation-and-iteration) in den Best Practices für das Erstellen von Skills. Zur allgemeinen Evaluierungsmethodik siehe [Erfolgskriterien definieren und Evaluierungen erstellen](https://platform.claude.com/docs/de/test-and-evaluate/develop-tests).

### Evaluierungen für Lebenszyklusentscheidungen nutzen

Evaluierungsergebnisse signalisieren, wann gehandelt werden muss:

* **Sinkende Auslösegenauigkeit:** Aktualisiere die Beschreibung oder die Anweisungen des Skills
* **Koexistenzkonflikte:** Konsolidiere überlappende Skills oder schärfe Beschreibungen
* **Durchgehend niedrige Ausgabequalität:** Schreibe Anweisungen neu oder füge Validierungsschritte hinzu
* **Anhaltende Fehler über Updates hinweg:** Kündige den Skill ab

## Skill-Lebenszyklusmanagement

<Steps>
  <Step title="Planen">
    Identifiziere Workflows, die sich wiederholen, fehleranfällig sind oder Fachwissen erfordern. Ordne diese organisatorischen Rollen zu und bestimme, welche davon Kandidaten für Skills sind.
  </Step>

  <Step title="Erstellen und prüfen">
    Stelle sicher, dass der Skill-Autor die [Best Practices](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/best-practices) befolgt. Verlange eine Sicherheitsprüfung anhand der [Prüf-Checkliste](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/enterprise#review-checklist). Verlange eine Evaluierungssuite vor der Genehmigung. Richte eine Aufgabentrennung ein: Skill-Autoren sollten nicht ihre eigenen Prüfer sein.
  </Step>

  <Step title="Testen">
    Verlange Evaluierungen in Isolation (Skill allein) und zusammen mit bestehenden Skills (Koexistenztests). Verifiziere Auslösegenauigkeit, Ausgabequalität und das Fehlen von Regressionen über dein aktives Skill-Set hinweg, bevor du für die Produktion genehmigst.
  </Step>

  <Step title="Bereitstellen">
    Lade Skills über die Skills API hoch, um Workspace-weiten Zugriff zu ermöglichen. Informationen zum Hochladen und zur Versionsverwaltung findest du unter [Agent Skills mit der API verwenden](https://platform.claude.com/docs/de/build-with-claude/skills-guide). Dokumentiere den Skill in deinem internen Verzeichnis mit Zweck, Verantwortlichem und Version.
  </Step>

  <Step title="Überwachen">
    Verfolge Nutzungsmuster und sammle Feedback von Nutzern. Führe Evaluierungen regelmäßig erneut aus, um Drift oder Regressionen zu erkennen, während sich Workflows und Modelle weiterentwickeln. Nutzungsanalysen sind derzeit nicht über die Skills API verfügbar. Implementiere Logging auf Anwendungsebene, um nachzuverfolgen, welche Skills in Anfragen enthalten sind.
  </Step>

  <Step title="Iterieren oder abkündigen">
    Verlange, dass die vollständige Evaluierungssuite besteht, bevor neue Versionen freigegeben werden. Aktualisiere Skills, wenn sich Workflows ändern oder Evaluierungswerte sinken. Kündige Skills ab, wenn Evaluierungen durchgehend fehlschlagen oder der Workflow eingestellt wird.
  </Step>
</Steps>

## Skills in großem Maßstab organisieren

### Recall-Grenzen

Als allgemeine Richtlinie solltest du die Anzahl gleichzeitig geladener Skills begrenzen, um eine zuverlässige Abrufgenauigkeit zu gewährleisten. Die Metadaten jedes Skills (Name und Beschreibung) konkurrieren im System-Prompt um Aufmerksamkeit. Wenn zu viele Skills aktiv sind, wählt Claude möglicherweise nicht den richtigen Skill aus oder übersieht relevante Skills vollständig. Verwende deine Evaluierungssuite, um die Abrufgenauigkeit beim Hinzufügen von Skills zu messen, und höre auf, weitere hinzuzufügen, wenn die Leistung nachlässt.

Beachte, dass API-Anfragen maximal 20 Skills pro Anfrage unterstützen (siehe [Agent Skills mit der API verwenden](https://platform.claude.com/docs/de/build-with-claude/skills-guide)). Wenn eine Rolle mehr Skills erfordert, als eine einzelne Anfrage unterstützt, erwäge, eng gefasste Skills zu breiteren zusammenzufassen oder Anfragen je nach Aufgabentyp an unterschiedliche Skill-Sets weiterzuleiten.

### Spezifisch beginnen, später konsolidieren

Ermutige Teams, mit engen, workflowspezifischen Skills zu beginnen statt mit breiten Mehrzweck-Skills. Wenn sich organisationsweit Muster herausbilden, konsolidiere verwandte Skills zu rollenbasierten Bündeln.

<Tip>
  Nutze Evaluierungen, um zu entscheiden, wann konsolidiert werden soll. Führe enge Skills nur dann zu einem breiteren zusammen, wenn die Evaluierungen des konsolidierten Skills eine gleichwertige Leistung gegenüber den einzelnen Skills bestätigen, die er ersetzt.
</Tip>

**Beispielhafter Verlauf:**

* Start: `formatting-sales-reports`, `querying-pipeline-data`, `updating-crm-records`
* Konsolidieren: `sales-operations` (wenn Evals gleichwertige Leistung bestätigen)

### Benennung und Katalogisierung

Verwende organisationsweit einheitliche Namenskonventionen. Der Abschnitt [Namenskonventionen](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/best-practices#naming-conventions) in den Best Practices bietet Formatierungshinweise.

Führe für jeden Skill ein internes Register mit:

* **Zweck:** Welchen Workflow der Skill unterstützt
* **Eigentümer:** Team oder Person, die für die Wartung verantwortlich ist
* **Version:** Aktuell bereitgestellte Version
* **Abhängigkeiten:** Erforderliche MCP-Server, Pakete oder externe Dienste
* **Evaluierungsstatus:** Datum und Ergebnisse der letzten Evaluierung

### Rollenbasierte Bündel

Gruppiere Skills nach organisatorischer Rolle, um das aktive Skill-Set jedes Nutzers fokussiert zu halten:

* **Vertriebsteam:** CRM-Operationen, Pipeline-Reporting, Angebotserstellung
* **Engineering:** Code-Review, Deployment-Workflows, Reaktion auf Vorfälle
* **Finanzen:** Berichtserstellung, Datenvalidierung, Audit-Vorbereitung

Jedes rollenbasierte Bündel sollte nur die Skills enthalten, die für die täglichen Workflows dieser Rolle relevant sind.

## Verteilung und Versionskontrolle

### Quellcodeverwaltung

Speichere Skill-Verzeichnisse in Git, um die Historie nachzuverfolgen, Code-Reviews über Pull Requests durchzuführen und Rollbacks zu ermöglichen. Jedes Skill-Verzeichnis (mit `SKILL.md` und allen mitgelieferten Dateien) lässt sich natürlich einem von Git verfolgten Ordner zuordnen.

### API-basierte Verteilung

Die Skills API bietet eine Workspace-bezogene Verteilung. Über die API hochgeladene Skills stehen allen Workspace-Mitgliedern zur Verfügung. Auf Claude Models on Google Cloud (Anthropic managed) funktioniert das Teilen anders. Details findest du im Abschnitt [Freigabebereich](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/overview#sharing-scope) der Agent-Skills-Übersicht. Informationen zu Endpunkten für Hochladen, Versionierung und Verwaltung findest du unter [Agent Skills mit der API verwenden](https://platform.claude.com/docs/de/build-with-claude/skills-guide).

### Versionierungsstrategie

* **Produktion:** Pinne Skills auf bestimmte Versionen. Wenn du `version` weglässt, verwenden Anfragen die neueste Version, sodass eine von irgendjemandem im Workspace hochgeladene neue Version sofort ändert, was Produktionsagenten ausführen. Führe die vollständige Evaluierungssuite aus, bevor du eine neue Version freigibst. Behandle jedes Update als neue Bereitstellung, die eine vollständige Sicherheitsprüfung erfordert.
* **Entwicklung und Test:** Verwende die neuesten Versionen, um Änderungen vor der Freigabe für die Produktion zu validieren.
* **Rollback-Plan:** Halte die vorherige Version als Fallback bereit. Wenn eine neue Version in der Produktion Evaluierungen nicht besteht, kehre sofort zur letzten bekanntermaßen funktionierenden Version zurück.
* **Integritätsprüfung:** Berechne Prüfsummen geprüfter Skills und verifiziere sie zum Zeitpunkt der Bereitstellung. Verwende signierte Commits in deinem Skill-Repository, um die Herkunft sicherzustellen.

### Oberflächenübergreifende Überlegungen

<Warning>
  Benutzerdefinierte Skills werden nicht über Oberflächen hinweg synchronisiert. In die API hochgeladene Skills sind nicht auf claude.ai oder in Claude Code verfügbar und umgekehrt. Jede Oberfläche erfordert separate Uploads und separate Verwaltung.
</Warning>

Pflege Skill-Quelldateien in Git als einzige maßgebliche Quelle. Wenn deine Organisation Skills über mehrere Oberflächen hinweg bereitstellt, implementiere einen eigenen Synchronisierungsprozess, um sie konsistent zu halten. Vollständige Details findest du unter [oberflächenübergreifende Verfügbarkeit](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/overview#cross-surface-availability).

## Nächste Schritte

<CardGroup cols={2}>
  <Card title="Agent Skills" icon="book-open" href="https://platform.claude.com/docs/de/agents-and-tools/agent-skills/overview">
    Architektur- und Plattformdetails
  </Card>

  <Card title="Best Practices für das Erstellen von Skills" icon="lightbulb" href="https://platform.claude.com/docs/de/agents-and-tools/agent-skills/best-practices">
    Erstellungshinweise für Skill-Autoren
  </Card>

  <Card title="Agent Skills mit der API verwenden" icon="code" href="https://platform.claude.com/docs/de/build-with-claude/skills-guide">
    Skills programmatisch hochladen und verwalten
  </Card>
</CardGroup>
