Elastic Agent Skills

Elastic Agent Skills — entwickelt von den Menschen, die Elastic gebaut haben — bringen native Plattform-Expertise direkt in deinen KI-Coding-Agenten. Dies ist die offizielle Agent-Skills-Bibliothek, kompatibel mit agentischen IDEs wie Cursor, GitHub Copilot, Windsurf, Gemini CLI und weiteren. Die Skills folgen dem offenen Standard Agent Skills.

[!NOTE] Technical Preview

Diese Skills befinden sich in einer frühen Veröffentlichungsphase und werden aktiv weiterentwickelt. Rechne mit Änderungen, während die Skills mit robusten Evaluierungen kodifiziert werden und sich die Modelllandschaft weiterentwickelt. Schau regelmäßig vorbei, um auf dem Laufenden zu bleiben.

Über

Dieses Repository enthält kuratierte Skills, also Pakete aus Anweisungen, Kontext und Tooling, die jedem KI-Agenten beibringen, wie er korrekt mit Elasticsearch, Kibana, Elastic Observability und Elastic Security arbeitet. Binde sie in die Agent-Runtime ein, die du bereits verwendest, und dein Assistent verwendet keine veralteten Muster mehr, sondern macht es richtig.

Was sind Skills?

Skills sind eigenständige Pakete, die KI-Agenten das Wissen und die Werkzeuge geben, um bestimmte Aufgaben auf wiederholbare Weise zu erledigen. Jeder Skill liegt in einem eigenen Ordner mit einer SKILL.md-Datei, die Metadaten und Anweisungen enthält, denen der Agent folgt.

Weiteren Hintergrund zum Agent-Skills-Standard findest du unter agentskills.io.

Umfang

Die Skills in diesem Repository konzentrieren sich auf:

• Die Interaktion mit Elasticsearch-APIs (Suche, Indexierung, Cluster-Verwaltung)
• Das Erstellen und Verwalten von Kibana-Inhalten wie Alerts, Connectoren und mehr
• Muster für Elastic Observability, Elastic Security und Agent Builder

Verfügbare Skills

Sicherheitsüberlegungen

KI-Coding-Agenten arbeiten mit echten Anmeldedaten, echtem Shell-Zugriff und oft mit den vollen Berechtigungen des Benutzers, der sie ausführt. Wenn diese Agenten auf Sicherheits-Workflows gerichtet werden, sind die Einsätze höher. Das rechtfertigt ein offenes Gespräch über Risiken, bevor du beginnst.

• Führe deine eigene Bedrohungsmodellierung durch. Bewerte, auf welche Daten der Agent zugreifen kann, welche Aktionen er ausführen kann und was passiert, wenn er sich unerwartet verhält. Die gemeinsame CISA-Leitlinie zum sicheren Bereitstellen von KI-Systemen ist ein guter Ausgangspunkt.
• Sei dir bewusst, welche Daten durch den Agenten fließen. Sicherheitsdaten können PII, in Kommandozeilen eingebettete Anmeldedaten und andere regulierte Daten enthalten. Wenn ein Agent Alerts oder Prozessereignisse abfragt, gelangt dieser Inhalt in den Kontext des Modells und kann an eine Drittanbieter-API gesendet werden. Beziehe deine Infosec- und Compliance-Teams frühzeitig ein.
• Diese Agenten verarbeiten angreifergesteuerte Eingaben. Alerts, Ereignisfelder und Dateiinhalte enthalten regelmäßig von Angreifern erstellte Zeichenketten. Prompt Injection ist hier nicht theoretisch; sie ist eine inhärente Eigenschaft der Betriebsumgebung. Forschung wie Brainworm zeigt, dass allein Agent-Kontextdateien als Persistenzmechanismus für Promptware dienen können.
• Begrenze Berechtigungen streng. Gib API-Schlüsseln die minimal erforderlichen Berechtigungen. Breite Response-Berechtigungen sind besonders gefährlich. Read-only-Zugriff ist eine gute Standardeinstellung, bis du das Verhalten validiert hast.
• Beschränke den Tool-Zugriff und die Netzwerkreichweite des Agenten. Die meisten KI-Coding-Agenten werden mit breiten Standardeinstellungen ausgeliefert: Shell-Ausführung, Dateisystem-Schreibzugriffe, Internetzugang. Die Reduzierung der verfügbaren Tool-Oberfläche begrenzt, was ein kompromittierter oder fehlgeleiteter Agent tun kann.
• Beginne in Nicht-Produktionsumgebungen. Verwende ein Serverless-Trial-Projekt, einen Dev-Cluster oder einen isolierten Kibana-Space, um Skills zu evaluieren, bevor du sie mit etwas verbindest, das Live-Sicherheitsdaten enthält.

Diese Skills sind genau deshalb Open Source, damit du überprüfen kannst, was sie tun. Wir ermutigen dich, sie zu lesen, bevor du sie ausführst.

Erste Schritte

Du kannst Elastic-Skills mit dem nativen Plugin-System von Claude Code, der skills CLI mit npx oder durch Klonen dieses Repositorys und Ausführen des mitgelieferten Installer-Skripts installieren. Die npx-Methode erfordert Node.js mit in deiner Umgebung verfügbarem npx.

[!TIP] Installiere nicht jeden Skill. Jeder installierte Skill fügt Routing-Kontext hinzu, den dein Agent bei jeder Anfrage auswertet. Installiere die cloud- und elasticsearch-Auth-Skills — die meisten anderen Skills hängen von ihnen ab — und füge dann nur die Skills hinzu, die für deinen Workflow relevant sind. Ein fokussiertes installiertes Set vermeidet Kontext-Bloat und hilft dem Agenten, zuverlässig zum richtigen Skill zu routen.

Claude Code Plugin (Empfohlen für Claude Code-Nutzer)

Claude Code hat ein natives Plugin-System, das Skills direkt verwaltet. Beginne damit, dieses Repository als Marketplace-Quelle hinzuzufügen:```sh claude plugin marketplace add https://github.com/elastic/agent-skills

Nach dem Hinzufügen können einzelne Plugins nach Namen installiert werden:```sh
claude plugin install elastic-elasticsearch@elastic-agent-skills
claude plugin install elastic-kibana@elastic-agent-skills
claude plugin install elastic-observability@elastic-agent-skills
claude plugin install elastic-security@elastic-agent-skills
claude plugin install elastic-cloud@elastic-agent-skills

[!NOTE] Nach der Installation werden Skills beim Ausführen von /reload-plugins möglicherweise nicht sofort angezeigt. Dies ist ein bekanntes Problem von Claude Code — starte deine Claude Code-Sitzung neu, um neu installierte Plugins zu übernehmen.

Oder verwende den interaktiven Plugin-Browser innerhalb einer beliebigen Claude Code-Sitzung:``` /plugins

Dies öffnet ein Menü zum Durchsuchen der verfügbaren Plugins aus allen konfigurierten Marktplätzen, zur Auswahl der zu installierenden Plugins und zur Verwaltung der bereits installierten.

### GitHub Copilot CLI

GitHub Copilot CLI verfügt über ein natives Plugin-System. Fügen Sie dieses Repository als Marktplatzquelle hinzu:```sh
copilot plugin marketplace add elastic/agent-skills

Sobald sie hinzugefügt wurden, installieren Sie einzelne Plugins nach Namen:```sh copilot plugin install elasticsearch@elastic-agent-skills copilot plugin install kibana@elastic-agent-skills copilot plugin install observability@elastic-agent-skills copilot plugin install security@elastic-agent-skills copilot plugin install cloud@elastic-agent-skills

Oder durchsuchen Sie verfügbare Plugins interaktiv innerhalb einer Copilot-Sitzung:```
/plugin list

npx (Empfohlen)

Der schnellste Weg, Skills zu installieren, ist die skills CLI. Es ist nicht nötig, dieses Repository zu klonen — führen Sie einfach aus:```sh npx skills add elastic/agent-skills

Dies startet eine interaktive Eingabeaufforderung zur Auswahl von Skills und [Ziel-Agents](https://github.com/vercel-labs/skills?tab=readme-ov-file#supported-agents). Die CLI kopiert jeden Skill-Ordner an den richtigen Ort, damit der Agent ihn entdecken kann.

Installiere einen bestimmten Skill nach Namen:```sh
npx skills add elastic/agent-skills --skill elasticsearch-esql

Oder verwende die @-Kurzschreibweise, um die Skill direkt als repo@skill anzugeben (entspricht --skill):```sh npx skills add elastic/agent-skills@elasticsearch-esql

Installation für bestimmte Agents (siehe [unterstützte Agents](https://github.com/vercel-labs/skills?tab=readme-ov-file#supported-agents)):```sh
npx skills add elastic/agent-skills -a cursor -a claude-code

Verfügbare Skills auflisten, ohne sie zu installieren:```sh npx skills add elastic/agent-skills --list

Alle Skills zu allen Agents installieren (nicht interaktiv):```sh
npx skills add elastic/agent-skills --all

Lokaler Klon

Wenn du lieber mit einer lokalen Arbeitskopie arbeitest oder deine Umgebung kein Node.js / npx hat, klone das Repository und verwende den mitgelieferten Bash-Installer:```sh git clone https://github.com/elastic/agent-skills.git cd agent-skills ./scripts/install-skills.sh add -a

Das Skript erfordert bash 3.2+ und Standard-Unix-Dienstprogramme (`awk`, `find`, `cp`, `rm`, `mkdir`).

| Flag              | Beschreibung                          |
| ----------------- | ------------------------------------- |
| `-a, --agent`     | Ziel-Agent (wiederholbar)             |
| `-s, --skill`     | Bestimmte Skills nach Namen installieren |
| `-f, --force`     | Bereits installierte Skills überschreiben |
| `-y, --yes`       | Bestätigungsaufforderungen überspringen |

Alle verfügbaren Skills auflisten:```sh
./scripts/install-skills.sh list

Unterstützte Agents

Skills aktualisieren

Der Aktualisierungsprozess hängt davon ab, wie die Skills installiert wurden.

Claude Code Plugin

Alle installierten Plugins auf ihre neuesten Versionen aktualisieren:```sh claude plugin update

Aktualisiere ein bestimmtes Plugin:```sh
claude plugin update elastic-elasticsearch

Um Plugins automatisch aktuell zu halten, aktiviere die Auto-Aktualisierung mit /plugins innerhalb von Claude Code.

Wenn die Auto-Aktualisierung aktiviert ist, prüft Claude Code beim Start auf neue Plugin-Versionen und aktualisiert im Hintergrund.

GitHub Copilot CLI

Aktualisiere alle installierten Plugins auf ihre neuesten Versionen:```sh copilot plugin update

Aktualisiere ein bestimmtes Plugin:```sh
copilot plugin update elasticsearch

npx

Prüfen Sie, ob sich installierte Skills upstream geändert haben:```sh npx skills check

Lade die neuesten Versionen aller installierten Skills herunter:```sh
npx skills update

Die CLI verfolgt das Quell-Repository jedes Skills und einen Inhalts-Hash in einer Lock-Datei. check vergleicht deine lokalen Hashes mit GitHub; update lädt alles, was abgewichen ist, erneut herunter.

Tipp: Die Standard-npx-Installation verwendet Symlinks, sodass jeder Agent auf eine einzige kanonische Kopie verweist. Ein einmaliges Aktualisieren frischt alle Agenten gleichzeitig auf.

Lokaler Klon

Führe den Installer erneut mit --force aus, um vorhandene Skills zu überschreiben:```sh git pull ./scripts/install-skills.sh add -a --force

Ohne `--force` überspringt das Skript Skills, die bereits installiert sind.

## Skill-Format

Jeder Skill-Ordner enthält eine `SKILL.md` mit YAML-Frontmatter und Markdown-Anweisungen:```yaml
---
name: elasticsearch-my-skill
description: >
  What the skill does AND when an agent should activate it.
metadata:
  version: 0.1.0
  visibility: public
---

# My Skill

[Instructions that the agent follows when this skill is active]

Das Feld description ist der einzige Auslösemechanismus — Agenten-Laufzeitumgebungen lesen es, um zu entscheiden, wann ein Skill geladen wird. Die vollständige Formatspezifikation finden Sie unter agentskills.io/specification.

Issues

Ein Problem gefunden oder einen Vorschlag? Öffnen Sie ein Issue und wir werden es prüfen.

Disclaimer

Diese Skills werden wie besehen bereitgestellt. Testen Sie Skills stets gründlich in Ihrer eigenen Umgebung, bevor Sie sich bei kritischen Aufgaben auf sie verlassen.