Elastic Agent Skills

Elastic Agent Skills – entwickelt von den Leuten, 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 mehr. Die Skills folgen dem offenen Agent Skills-Standard.

[!NOTE] Technische Vorschau

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

Über dieses Repository

Dieses Repository enthält kuratierte Skills – Pakete aus Anweisungen, Kontext und Werkzeugen – die jedem KI-Agenten beibringen, korrekt mit Elasticsearch, Kibana, Elastic Observability und Elastic Security zu arbeiten. Füge sie in die Agenten-Laufzeitumgebung ein, die du bereits verwendest, und dein Assistent hört auf, veraltete Muster zu nutzen, und macht es von Anfang an 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 lebt in einem eigenen Ordner mit einer SKILL.md-Datei, die Metadaten und Anweisungen enthält, denen der Agent folgt.

Weitere Hintergrundinformationen zum Agent-Skills-Standard findest du unter agentskills.io.

Umfang

Die Skills in diesem Repository konzentrieren sich auf:

• Interaktion mit Elasticsearch-APIs (Suche, Indizierung, Cluster-Verwaltung)
• Erstellen und Verwalten von Kibana-Inhalten wie Alerts, Connectors 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 vollständigen Berechtigungen des Benutzers, der sie ausführt. Wenn diese Agenten auf Sicherheits-Workflows ausgerichtet werden, sind die Einsätze höher. Das rechtfertigt ein offenes Gespräch über Risiken, bevor du loslegst.

• 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 Anleitung der CISA zur sicheren Bereitstellung von KI-Systemen ist ein guter Ausgangspunkt.
• Sei dir bewusst, welche Daten durch den Agenten fließen. Sicherheitsdaten können PII, in Befehlszeilen 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 angreiferkontrollierte Eingaben. Alerts, Ereignisfelder und Dateiinhalte enthalten regelmäßig Zeichenfolgen, die von Angreifern erstellt wurden. Prompt Injection ist hier nicht theoretisch; es ist eine inhärente Eigenschaft der Betriebsumgebung. Forschung wie Brainworm zeigt, dass Agenten-Kontextdateien allein als Persistenzmechanismus für Promptware dienen können.
• Begrenze Berechtigungen strikt. Gib API-Schlüsseln die minimal erforderlichen Berechtigungen. Breite Antwortberechtigungen sind besonders gefährlich. Schreibgeschützter Zugriff ist ein guter Standard, 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-Schreibzugriff, Internetzugriff. Die Reduzierung der verfügbaren Tool-Oberfläche begrenzt, was ein kompromittierter oder fehlgeleiteter Agent tun kann.
• Starte in Nicht-Produktionsumgebungen. Verwende ein Serverless-Testprojekt, 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 prüfen kannst, was sie tun. Wir ermutigen dich, sie zu lesen, bevor du sie ausführst.

Erste Schritte

Du kannst Elastic-Skills über das native Plugin-System von Claude Code, die skills-CLI mit npx oder durch Klonen dieses Repositorys und Ausführen des gebündelten Installationsskripts installieren. Die npx-Methode erfordert Node.js mit verfügbarem npx in deiner Umgebung.

[!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. Den installierten Satz fokussiert zu halten, vermeidet Kontextaufblähung und hilft dem Agenten, zuverlässig zum richtigen Skill zu routen.

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

Claude Code verfügt über 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

Sobald hinzugefügt, installiere einzelne Plugins per Name:```sh
claude plugin install elasticsearch@elastic-agent-skills
claude plugin install kibana@elastic-agent-skills
claude plugin install observability@elastic-agent-skills
claude plugin install security@elastic-agent-skills
claude plugin install cloud@elastic-agent-skills

[!NOTE] Nach der Installation erscheinen Skills möglicherweise nicht sofort beim Ausführen von /reload-plugins. Dies ist ein bekanntes Claude-Code-Problem – starten Sie Ihre Claude-Code-Sitzung neu, um neu installierte Plugins zu übernehmen.

Oder verwenden Sie den interaktiven Plugin-Browser in einer beliebigen Claude-Code-Sitzung:``` /plugins

Dies öffnet ein Menü zum Durchsuchen verfügbarer Plugins aus allen konfigurierten Marktplätzen, zur Auswahl, was installiert werden soll, und zur Verwaltung dessen, was bereits installiert ist.

### 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 hinzugefügt, installiere 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 mit der skills CLI. Es ist nicht nötig, dieses Repository zu klonen — führen Sie einfach Folgendes 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 Speicherort, damit der Agent ihn entdecken kann.

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

Or verwende die @-Kurzform, um die Fähigkeit direkt als repo@skill anzugeben (entspricht --skill):```sh npx skills add elastic/agent-skills@elasticsearch-esql

Installieren 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

Liste verfügbarer Fähigkeiten ohne Installation anzeigen:```sh npx skills add elastic/agent-skills --list

Installiere alle Skills für alle Agents (nicht-interaktiv):```sh
npx skills add elastic/agent-skills --all

Lokaler Klon

Wenn Sie lieber mit einem lokalen Checkout arbeiten oder Ihre Umgebung kein Node.js / npx besitzt, klonen Sie das Repository und verwenden Sie den gebündelten 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 Name installieren |
| `-f, --force`     | Bereits installierte Skills überschreiben |
| `-y, --yes`       | Bestätigungsabfragen überspringen    |

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

Unterstützte Agents

Aktualisieren von Skills

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

Claude Code Plugin

Aktualisieren Sie alle installierten Plugins auf ihre neuesten Versionen:```sh claude plugin update

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

Um Plugins automatisch auf dem neuesten Stand zu halten, aktiviere das automatische Update mit /plugins in Claude Code.

Wenn das automatische Update aktiviert ist, prüft Claude Code beim Start nach neuen Plugin-Versionen und aktualisiert diese 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

Überprüfen, ob sich bei installierten Skills upstream etwas geändert hat:```sh npx skills check

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

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

Tipp: Die Standard-npx-Installation verwendet Symlinks, sodass jeder Agent auf eine einzige kanonische Kopie zeigt. Ein einziges Update aktualisiert alle Agenten gleichzeitig.

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 bereits installierte Skills.

## 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 alleinige Auslösemechanismus – Agent-Laufzeitumgebungen lesen es, um zu entscheiden, wann eine Fähigkeit geladen werden soll. Die vollständige Formatspezifikation finden Sie unter agentskills.io/specification.

Probleme

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

Haftungsausschluss

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