agent-skills v0.4.0
Compétences Elastic officielles
Elastic Agent Skills
Elastic Agent Skills — conçu par les personnes qui ont construit Elastic — apporte une expertise native de la plateforme directement à votre agent de codage IA. Il s'agit de la bibliothèque officielle d'Agent Skills, compatible avec les IDE agentiques tels que Cursor, GitHub Copilot, Windsurf, Gemini CLI, et plus encore. Les skills suivent le standard ouvert Agent Skills.
[!NOTE] Technical Preview
Ces skills sont en version préliminaire et en cours de développement actif. Attendez-vous à des changements à mesure que les skills sont codifiés avec des évaluations robustes et que le paysage des modèles évolue. Revenez régulièrement pour les mises à jour.
À propos
Ce dépôt contient des skills sélectionnés qui sont des packages d'instructions, de contexte et d'outillage qui apprennent à tout agent IA comment travailler correctement avec Elasticsearch, Kibana, Elastic Observability et Elastic Security. Déposez-les dans le runtime d'agent que vous utilisez déjà, et votre assistant cessera d'utiliser des patterns obsolètes et commencera à faire les choses correctement.
Que sont les skills ?
Les skills sont des packages autonomes qui donnent aux agents IA les connaissances et les outils nécessaires pour accomplir des tâches spécifiques de manière reproductible. Chaque skill réside dans son propre dossier avec un fichier SKILL.md contenant les métadonnées et les instructions que l'agent suit.
Pour plus d'informations sur le standard Agent Skills, consultez agentskills.io.
Périmètre
Les skills de ce dépôt se concentrent sur :
- L'interaction avec les API Elasticsearch (recherche, indexation, gestion de cluster)
- La création et la gestion de contenu Kibana tel que les alertes, les connecteurs, et plus encore
- Les patterns pour Elastic Observability, Elastic Security et Agent Builder
Skills disponibles
Cloud (2)
| Skill | Description | Version | Author |
|---|---|---|---|
| cloud-onboarding | Onboard an Elastic Cloud organization: configure the elastic CLI's Cloud context and API key, establish a default region, then invite users, assign predefined or custom Serverless project roles, and create or revoke Cloud API keys. Use when setting up Cloud authentication or when granting, modifying, or auditing user access to an organization and its projects. | 0.3.0 | elastic |
| cloud-provisioning | Provision and operate Elastic Cloud infrastructure: create, connect to, update, and delete Serverless projects (Elasticsearch, Observability, Security); manage traffic filters (IP and AWS PrivateLink network security); and manage the lifecycle of Elastic Cloud Hosted deployments. Use when creating or performing day-2 operations on serverless projects or hosted deployments, or restricting their network access. | 0.3.0 | elastic |
Elasticsearch (10)
| Skill | Description | Version | Author |
|---|---|---|---|
| elasticsearch-anomaly-detection | Create and manage Elastic ML anomaly detection jobs via the API. Use when setting up jobs on an index or data stream, configuring jobs and datafeeds, or opening, starting, or stopping them. | 1.1.0 | elastic |
| elasticsearch-anomaly-detection-explainer | Explain Elasticsearch ML anomaly detection scores, model behavior, and result interpretation. Use when the user asks why a score is high or low, how the model learns, what the numbers mean, or how to troubleshoot unexpected anomaly scores. | 0.3.0 | elastic |
| elasticsearch-cluster-health | Diagnose a non-green Elasticsearch cluster and surface the single most likely cause with remediation. Use when an operator reports yellow or red status, unassigned shards, allocation failures, or wants read-only triage before deeper investigation. Teaches replica-vs-primary impact, allocation decider classification, and data-loss awareness. | 0.1.0 | elastic |
| elasticsearch-esql | Execute ES|QL (Elasticsearch Query Language) queries, use when the user wants to query Elasticsearch data, analyze logs, aggregate metrics, explore data, or create charts and dashboards from ES|QL results. | 0.7.0 | elastic |
| elasticsearch-index-design | Design and review Elasticsearch index mappings for stated access patterns: correct field types, text+keyword multi-fields, doc_values tuning, mapping-explosion avoidance, and explicit shard settings. Use when creating a new index, reviewing a mapping for storage or query performance, fixing wrong field types, or when the user asks which type to use for search, filter, sort, or aggregation on a field. | 0.1.0 | elastic |
| elasticsearch-ingest | Load CSV and JSON files into Elasticsearch indices using the bulk API and explicit mappings when field types matter. Use when batch-importing local files, converting CSV rows or JSON arrays to NDJSON bulk format, or verifying document counts and mappings after ingest — not for Logstash pipelines, Beats, custom scripts, or index-to-index reindex. | 0.1.0 | elastic |
| elasticsearch-onboarding | Help developers new to Elasticsearch get from zero to a working search experience. Guide them through understanding their intent, mapping their data, and building a search experience with best practices baked in. Use this when the user shows intent to build search-related functionality, asks about Elasticsearch-related concepts for their use case, or expresses the need for help getting started with Elasticsearch. | 0.1.0 | elastic |
| elasticsearch-query-optimization | Diagnose slow Elasticsearch Query DSL searches and propose measured fixes. Use when a search is slow, profile output shows an expensive clause, exact-match filters sit in scoring context, or leading wildcards dominate latency. Ground every recommendation in search profiling — move non-scoring clauses to filter context, eliminate leading wildcards, and re-profile to confirm improvement. | 0.1.0 | elastic |
| elasticsearch-reindex | Guide Elasticsearch reindex for performance: local and remote, slicing, throttling, task API. Use when copying or migrating indices, changing mappings, or transforming during reindex. | 0.2.0 | elastic |
| elasticsearch-search-relevance | Improve Elasticsearch search relevance for content and catalog indices: pin or promote results with query rules (correct rule type, criteria, and rule-query wiring) and tune organic ranking with multi_match, field boosts, and analysis grounded in the index mapping. Use when search results rank poorly, a specific document must appear first for a query, or the user asks to tune full-text matching — not for ES|QL analytics, index ingest, or cluster health. | 0.1.0 | elastic |
Kibana (5)
| Skill | Description | Version | Author |
|---|---|---|---|
| kibana-agent-builder | Create and manage Kibana Agent Builder agents and custom tools. Use when asked to create, update, delete, test, or inspect agents or tools in Agent Builder, or when the user wants to understand what agents or tools already exist. | 0.3.0 | elastic |
| kibana-alerting-rules | Create and manage Kibana alerting rules. Use when creating, updating, or managing rule lifecycle (enable, disable, mute, snooze), choosing metric threshold rule types and params, or read-only find/list with tag filters. | 0.3.0 | elastic |
| kibana-anomaly-detection | Elastic ML anomaly detection — investigation/RCA, score explanation, job lifecycle troubleshooting, and job operations. Use when answering "what broke?"/"which entity?"/RCA, "why is score high/low?"/renormalization, "datafeed stopped"/"memory limit"/hard_limit, or configuring ML anomaly detection jobs. Reads results from .ml-anomalies-* and job state from ML REST APIs. | 0.3.0 | elastic |
| kibana-dashboards | Create and manage Kibana Dashboards and Lens visualizations. Use when you need to define dashboards and visualizations declaratively, version control them, or automate their deployment. | 0.3.0 | elastic |
| kibana-workflows | Author, validate, test, run, and inspect Elastic Workflow YAML definitions. Use when the user wants to turn natural language into a Kibana workflow, fix workflow YAML, understand triggers or steps, or run a quick test loop against a real Kibana. | 0.5.0 | elastic |
Observability (5)
| Skill | Description | Version | Author |
|---|---|---|---|
| observability-k8s-investigation | Investigate Kubernetes workload, node, and control-plane issues using OTel telemetry (EDOT). Use when diagnosing pod failures (CrashLoopBackOff, OOMKilled, Error), node pressure, resource exhaustion, image pull failures, admission rejections, autoscaling anomalies, or correlating K8s state with application signals. OTel ingest path only — the legacy ECS Kubernetes integration shape is out of scope. | 0.5.1 | elastic |
| observability-llm-obs | Answer questions about LLM and agentic-application behavior from data already ingested into Elastic: latency and error rate, token and cost utilization, response quality and guardrail events, and agentic call-chain orchestration. Use when the user asks about LLM monitoring, GenAI observability, token spend or AI cost, model latency, prompt or guardrail failures, or how an agent's tool-call chain executed. | 0.3.1 | elastic |
| observability-onboarding | Onboard an application into Elastic Observability with the Elastic Distribution of OpenTelemetry (EDOT): route on language and runtime, detect and replace a classic Elastic APM agent, apply the required OTLP configuration, and then verify with ES|QL that traces, metrics, and logs actually arrive under the expected service name. Use when adding observability to a service, migrating off the classic Elastic APM agent, or debugging why an instrumented service is not showing up in Elastic. | 0.3.0 | elastic |
| observability-service-reliability | Design and operate service reliability targets in Elastic Observability: choose an SLI type and a defensible target, pick a time window and budgeting method, create and maintain SLOs through the Kibana API, attach burn-rate alert rules, and decide when an SLO is the wrong instrument and a threshold rule, anomaly job, or synthetics monitor is right. Use when defining or reviewing SLOs and error budgets, tuning burn-rate alerting, reducing alert noise, or setting up availability monitoring for a user-facing endpoint. | 0.4.1 | elastic |
| observability-sre-triage | Triage a degraded or suspect service end to end: read SLO status and burn rate, check active alerting rules and ML anomalies, measure throughput, latency, and error rate, assess dependency health and infrastructure saturation, and funnel logs down to the failures that explain it. Use when someone asks whether a service is healthy, why it is slow or erroring, what is in its logs, or which attribute distinguishes the requests that are failing. Also use when someone asks for the query behind any of those signals — throughput, latency percentiles, error rate, dependency health, or log volume — over APM/OTel traces, metrics, or logs. | 0.5.1 | elastic |
Security (4)
| Skill | Description | Version | Author |
|---|---|---|---|
| security-alert-triage | Triage Elastic Security alerts — gather context, classify threats, create cases, and acknowledge. Use when triaging alerts, performing SOC analysis, or investigating detections. | 0.1.0 | elastic |
| security-case-management | Create, search, update, and manage SOC cases via the Kibana Cases API. Use when tracking incidents, linking alerts to cases, adding investigation notes, or managing triage output. | 0.1.0 | elastic |
| security-detection-rule-management | Create, tune, and manage Elastic Security detection rules (SIEM and Endpoint). Use for false positives, exceptions, new coverage, noisy rules, or rule management via Kibana API. | 0.1.0 | elastic |
| security-generate-security-sample-data | Generate sample security events, attack scenarios, and synthetic alerts for Elastic Security. Use when demoing, populating dashboards, testing detection rules, or setting up a POC. | 0.1.0 | elastic |
Considérations de sécurité
Les agents de codage IA opèrent avec de véritables identifiants, un véritable accès au shell, et souvent avec l'ensemble des permissions de l'utilisateur qui les exécute. Lorsque ces agents sont orientés vers des workflows de sécurité, les enjeux sont plus élevés. Cela justifie une conversation franche sur les risques avant de commencer.
- Menez votre propre modélisation des menaces. Évaluez à quelles données l'agent peut accéder, quelles actions il peut entreprendre, et ce qui se passe s'il se comporte de manière inattendue. Les recommandations conjointes de la CISA sur le déploiement sécurisé des systèmes d'IA constituent un bon point de départ.
- Soyez conscient des données qui transitent par l'agent. Les données de sécurité peuvent contenir des PII, des identifiants intégrés dans des lignes de commande, et d'autres données réglementées. Lorsqu'un agent interroge des alertes ou des événements de processus, ce contenu entre dans le contexte du modèle et peut être envoyé à une API tierce. Impliquez vos équipes infosec et conformité dès le début.
- Ces agents traitent des entrées contrôlées par l'attaquant. Les alertes, les champs d'événements et le contenu des fichiers contiennent régulièrement des chaînes conçues par des attaquants. L'injection de prompt n'est pas théorique ici ; c'est une propriété inhérente de l'environnement d'exploitation. Des recherches comme Brainworm démontrent que les fichiers de contexte d'agent seuls peuvent servir de mécanisme de persistance pour du promptware.
- Limitez étroitement les privilèges. Accordez aux clés API le minimum de privilèges requis. Les privilèges de réponse étendus sont particulièrement dangereux. L'accès en lecture seule est une bonne valeur par défaut jusqu'à ce que vous ayez validé le comportement.
- Restreignez l'accès aux outils de l'agent et sa portée réseau. La plupart des agents de codage IA sont livrés avec des valeurs par défaut étendues : exécution de shell, écriture sur le système de fichiers, accès à Internet. Réduire la surface d'outils disponible limite ce qu'un agent compromis ou mal dirigé peut faire.
- Commencez dans des environnements hors production. Utilisez un projet d'essai Serverless, un cluster de développement, ou un espace Kibana isolé pour évaluer les skills avant de les connecter à quoi que ce soit contenant des données de sécurité en production.
Ces skills sont open source précisément pour que vous puissiez auditer ce qu'ils font. Nous vous encourageons à les lire avant de les exécuter.
Pour commencer
Vous pouvez installer les skills Elastic en utilisant le système de plugins natif de Claude Code, le CLI skills avec npx, ou en clonant ce dépôt et en exécutant le script d'installation fourni. La méthode npx nécessite Node.js avec npx disponible dans votre environnement.
[!TIP] N'installez pas tous les skills. Chaque skill installé ajoute du contexte de routage que votre agent évalue à chaque requête. Installez les skills d'authentification cloud et elasticsearch — la plupart des autres skills en dépendent — puis ajoutez uniquement les skills pertinents pour votre workflow. Garder l'ensemble installé ciblé évite la surcharge de contexte et aide l'agent à router vers le bon skill de manière fiable.
Plugin Claude Code (Recommandé pour les utilisateurs de Claude Code)
Claude Code dispose d'un système de plugins natif qui gère les skills directement. Commencez par ajouter ce dépôt comme source de marketplace :```sh claude plugin marketplace add https://github.com/elastic/agent-skills
Une fois ajouté, installez les plugins individuels par leur nom :```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] Après l'installation, les compétences peuvent ne pas apparaître immédiatement lors de l'exécution de
/reload-plugins. Il s'agit d'un problème connu de Claude Code — redémarrez votre session Claude Code pour prendre en compte les plugins nouvellement installés.
Ou utilisez le navigateur de plugins interactif dans n'importe quelle session Claude Code :``` /plugins
Cela ouvre un menu pour parcourir les plugins disponibles depuis tous les marketplaces configurés, sélectionner ceux à installer et gérer ceux déjà installés.
### GitHub Copilot CLI
GitHub Copilot CLI dispose d'un système de plugins natif. Ajoutez ce dépôt comme source de marketplace :```sh
copilot plugin marketplace add elastic/agent-skills
Une fois ajoutés, installez les plugins individuellement par leur nom :```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
Ou parcourez les plugins disponibles de manière interactive dans une session Copilot :```
/plugin list
npx (Recommandé)
Le moyen le plus rapide d'installer des compétences est d'utiliser la CLI skills. Pas besoin de cloner ce dépôt — exécutez simplement :```sh
npx skills add elastic/agent-skills
Cela lance une invite interactive pour sélectionner des compétences et des [agents cibles](https://github.com/vercel-labs/skills?tab=readme-ov-file#supported-agents). La CLI copie chaque dossier de compétence à l'emplacement correct pour que l'agent puisse le découvrir.
Installer une compétence spécifique par son nom :```sh
npx skills add elastic/agent-skills --skill elasticsearch-esql
Ou utilisez le raccourci @ pour spécifier directement la compétence sous la forme repo@skill (équivalent à --skill) :```sh
npx skills add elastic/agent-skills@elasticsearch-esql
Installer pour des agents spécifiques (voir [agents pris en charge](https://github.com/vercel-labs/skills?tab=readme-ov-file#supported-agents)) :```sh
npx skills add elastic/agent-skills -a cursor -a claude-code
Lister les compétences disponibles sans les installer :```sh npx skills add elastic/agent-skills --list
Installer toutes les compétences à tous les agents (non interactif) :```sh
npx skills add elastic/agent-skills --all
| Option | Description |
|---|---|
-a, --agent | Cibler des agents spécifiques (voir Supported agents) |
-s, --skill | Installer des compétences spécifiques par nom |
-g, --global | Installer dans le répertoire utilisateur au lieu du répertoire du projet |
-y, --yes | Ignorer les invites de confirmation |
--all | Installer toutes les compétences pour tous les agents sans invite |
--list | Lister les compétences disponibles sans les installer |
Clone local
Si vous préférez travailler à partir d'une copie locale, ou si votre environnement ne dispose pas de Node.js / npx, clonez le dépôt et utilisez l'installateur bash fourni :```sh git clone https://github.com/elastic/agent-skills.git cd agent-skills ./scripts/install-skills.sh add -a
Le script nécessite bash 3.2+ et les utilitaires Unix standard (`awk`, `find`, `cp`, `rm`, `mkdir`).
| Flag | Description |
| ----------------- | ------------------------------------- |
| `-a, --agent` | Agent cible (répétable) |
| `-s, --skill` | Installer des compétences spécifiques par nom |
| `-f, --force` | Écraser les compétences déjà installées |
| `-y, --yes` | Ignorer les invites de confirmation |
Lister toutes les compétences disponibles :```sh
./scripts/install-skills.sh list
Agents pris en charge
| Agent | Répertoire d'installation |
|---|---|
| claude-code | .claude/skills |
| cursor | .agents/skills |
| codex | .agents/skills |
| opencode | .agents/skills |
| pi | .pi/agent/skills |
| windsurf | .windsurf/skills |
| roo | .roo/skills |
| cline | .agents/skills |
| github-copilot | .agents/skills |
| gemini-cli | .agents/skills |
Mise à jour des skills
Le processus de mise à jour dépend de la façon dont les skills ont été installés.
Plugin Claude Code
Mettre à jour tous les plugins installés vers leurs dernières versions :```sh claude plugin update
Mettre à jour un plugin spécifique :```sh
claude plugin update elastic-elasticsearch
Pour maintenir les plugins à jour automatiquement, activez la mise à jour automatique via /plugins dans Claude Code.
Lorsque la mise à jour automatique est activée, Claude Code vérifie les nouvelles versions des plugins au démarrage et effectue les mises à jour en arrière-plan.
GitHub Copilot CLI
Mettre à jour tous les plugins installés vers leurs dernières versions :```sh copilot plugin update
Mettre à jour un plugin spécifique :```sh
copilot plugin update elasticsearch
npx
Vérifiez si des compétences installées ont été modifiées en amont :```sh npx skills check
Récupérez les dernières versions de toutes les compétences installées :```sh
npx skills update
La CLI suit le dépôt source de chaque compétence et un hachage de contenu dans un fichier de verrouillage. check compare vos hachages locaux à GitHub ; update retélécharge tout ce qui a dérivé.
Astuce : L'installation npx par défaut utilise des liens symboliques, de sorte que chaque agent pointe vers une copie canonique unique. Une mise à jour rafraîchit tous les agents en même temps.
Clone local
Relancez l'installateur avec --force pour écraser les compétences existantes :```sh
git pull
./scripts/install-skills.sh add -a --force
Sans `--force`, le script ignore les compétences déjà installées.
## Format des compétences
Chaque dossier de compétence contient un fichier `SKILL.md` avec un frontmatter YAML et des instructions en markdown :```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]
Le champ description est le seul mécanisme de déclenchement — les runtimes d'agents le lisent pour décider quand charger une compétence. Pour la spécification complète du format, voir agentskills.io/specification.
Problèmes
Vous avez trouvé un problème ou avez une suggestion ? Ouvrez un ticket et nous l'examinerons.
Avertissement
Ces compétences sont fournies telles quelles. Testez toujours les compétences de manière approfondie dans votre propre environnement avant de vous y fier pour des tâches critiques.