AI-Agent Skills vs MCP vs Plugins: was sollen Entwickler 2026 nutzen? Von Discovery bis JSON Schema

Falsche Frage: sie sind keine Rivalen auf einer Schicht

Der übliche Review-Fehler sind drei Karten auf dem Tisch und eine Stimme. Ein Skill legt kein tools/list offen und nimmt kein tools/call. Es ist ein Verzeichnis plus SKILL.md: beim Start kommen nur name und description in den Kontext (etwa hundert Tokens); Körper und scripts/, references/ laden bei Bedarf. Kein JSON-RPC, kein Handshake, kein „Skill-Eingabe-Schema“ auf der Leitung. MCP ist das Gegenteil: Prozess oder HTTP-Endpunkt, Argumente, die als JSON prüfen müssen. Ein Plugin tut keines von beiden. Es fixiert nur ein Verzeichnis und zwei geschlossene Manifeste. Ein Plugin als „stärkeres MCP“ zu sehen heißt, einen Karton für einen Motor zu halten.

Discovery ist auch kein Weg. Ein Skill wird über einen Beschreibungstext gefunden: „was + wann“ schreiben, sonst wählt das Modell ihn nicht. MCP wird über tools/list gefunden — Namen plus inputSchema. Ein Plugin über Root-plugin.json, dann die festen Orte skills/ und mcp.json. Die drei können stapeln: der Client sieht die Kiste, dann Skill-Metadaten, dann eine MCP-Werkzeugliste. Stapeln ist kein Ersetzen. Fehlt die Hand und Sie schreiben einen längeren Skill, wetten Sie, das Modell fälsche eine API per Shell. Das ist Halluzination, keine Integration.

Seitliche Delegation liegt nicht auf diesen drei Karten. Wie ein anderer Agent gefunden und mit einem Task betraut wird, ist eine A2A Agent Card; siehe A2A vs MCP. Heute entscheiden Sie nur: braucht dieses Repo eine Anleitung, eine Hand, müssen beide in ein portables Verzeichnis. Zuerst schichten, dann wählen.

Vier Fragen gehen den Entscheidungsbaum

Die Multiple Choice auf vier Fragen falten. Der Reihe nach antworten, nicht überspringen. Erstens: muss das Modell ein lebendes System außerhalb des Repos anfassen — Datenbank, offizielle Docs-Suche, Billing-API, gcloud? Ja: mindestens MCP (oder ein vorhandenes natives Werkzeug wie lokales gh). Nein: keinen leeren Server aufstellen, um ernst zu wirken. Zweitens: müssen Sie einen Ablauf wie „zuerst Projekt, dann Billing, keine Keys committen“ über Sitzungen halten? Ja: einen Skill schreiben. Ein geklebter Systemprompt verschwindet, wenn das Fenster eng wird.

Drittens: müssen die Antworten auf eins und zwei zusammen ausgeliefert werden? Ein Rechnungs-MCP ohne Wochennotiz-Skill wird missbraucht; der Skill ohne MCP demoed nur auf Fakedaten. Erst dann ein Plugin denken. Viertens: geht das an mehr als einen Client — Cursor, Claude Code, Antigravity, Codex? Eine IDE mit nativer MCP-/Skills-Installation ist als native Config kürzer. Google hat das im Developers Blog festgenagelt: ein Plugin lohnt, wenn die Teile dasselbe Ziel haben und zusammen reisen müssen.

Unten ein Entscheidungsprotokoll, das ins Repo darf. Kein Spez-Feld. Ein JSON-Fixture aus dem Review: die vier Antworten, die Wahl, die Komponentennamen, die Sie packen wollen. Parsen lassen, dann in der CI prüfen, dass choice nicht gegen die vier Flags kämpft — mustTravelTogether false und choice plugin ist zu frühes Einpacken.

{
  "task": "weekly-invoice-summary",
  "needRuntimeTools": true,
  "needReusableBrief": true,
  "mustTravelTogether": true,
  "clients": ["cursor", "claude-code", "antigravity"],
  "choice": "plugin",
  "components": [
    "skill:write-weekly-summary",
    "mcp:invoice-tools"
  ]
}

Nur Skill: Discovery ist die Description, es gibt kein tools/call

Ein Skill gewinnt in drei Dingen: kein Handshake, Laden bei Bedarf, Menschen können diffen. Beim Start injiziert der Client nur Metadaten; das Modell liest den Körper, wenn die Description trifft. Also muss die Description was und wann sagen, dritte Person, mit Schlüsselwörtern, mit Grenzen (name 64, description 1024). Ein interner Codename oder ein Ich-Slogan ist Discovery-Fläche null. Agent Skills besitzt das Format; Plugins sagt nur, es lebt unter skills/<name>/SKILL.md.

Ein Skill darf scripts/ mitbringen. Das sind keine neuen MCP-Werkzeuge. Sie heißen „mit der Shell, die du schon hast, das hier ausführen“. Das passt zu lokalen CLIs: gh, gcloud, Ihr lint.sh. Das Skript hält deterministische Arbeit vom Prompt fern und schreibt eine Zusammenfassung zurück. Trotzdem kein Transport: keine OAuth-Discovery, kein inputSchema; argv prüft das Skript. Brauchen Sie stabile JSON-Argumente oder Remote-Auth, tun Sie nicht so, als wäre ein Skript MCP.

Nur-Skill passt zu Ausgabeformaten (PR-Text, Vorfallsbericht), lokalen CLI-Abläufen und Domänen-Leitplanken („lies zuerst diese Checklist“). Anti-Muster: ein „Produktiv-DB abfragen“-Skill, der das Modell SQL erfinden und durch eine generische Shell jagen lässt. Eine Anleitung, die eine Hand spielt. In der Discovery können Sie auch keine Argumentform prüfen — es gibt kein Schema.

Nur MCP: Discovery ist tools/list, der Vertrag ist inputSchema

MCP gewinnt in drei Dingen, die ein Skill nicht gibt: lebende Verbindung, strukturierte Eingabe, Fehlergrenze. Der Client verbindet, tools/list liefert Namen und inputSchema, das Modell füllt Arguments, die Laufzeit ruft tools/call. Ob Arguments durchkommen, ist JSON Schema, nicht „das Modell klang sicher“. Auth, Quotas, Transportversionen bleiben auf der MCP-Spez; die zustandslose 2026-07-28-Fassung kann hinter einem normalen HTTP-Load-Balancer sitzen. Ein Skill tut keine dieser Schichten.

Ein Client, ein Server: lieber die native MCP-Config dieses Clients, nicht zuerst ein Plugin. mcp.json ist die portable Agent-Plugins-Form; Felder müssen nicht Cursor oder Gemini CLI gleichen. Der Client mappt. Eine IDE macht die Mapping-Schicht überflüssig. Erscheint ein zweiter Client, falten Sie dieselbe Verbindung in Root-mcp.json und ergänzen plugin.json — auch ohne skills/. Ein fehlendes Skills-Verzeichnis ist kein Fehler; die Spez sagt, fehlende Orte überspringen.

Die Discovery-Kette ist kurz: verbinden → tools/list → aus inputSchema füllen. Keine ganze OpenAPI-Datei als Werkzeugliste an einen MCP-Client werfen, keine Plugin-Manifest-Felder in inputSchema kopieren. Der Paketvertrag antwortet „ist die Kiste da“. Der Werkzeugvertrag antwortet „sind die Arguments dieses Hops legal“. Beides JSON Schema, eine Schicht Abstand. Unten ein portables MCP-Fragment, das Sie vor dem Einpacken schreiben können — später unverändert in die Plugin-Wurzel.

{
  "$schema": "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json",
  "mcpServers": {
    "invoice-tools": {
      "type": "stdio",
      "command": "./bin/invoice-mcp",
      "args": ["--data", "${PLUGIN_DATA}/invoices"],
      "cwd": "${PLUGIN_ROOT}"
    }
  }
}

Wann einpacken: Plugin lohnt bei vielen Komponenten und vielen Clients

Ein Plugin lohnt, wenn Frage drei und vier gleichzeitig leuchten. Typisches Paar: ein MCP, das Zahlen holt, plus ein Skill, der eine menschliche Wochennotiz schreibt; oder Googles Paar — gcloud-Leitplanken-Skills plus Developer-Knowledge-MCP. Jedes wird ohne das andere missbraucht: die Hand allein erfindet den Bericht; die Anleitung allein hat keine geerdete Docs-Suche. Nach dem Einpacken teilen Antigravity, Claude Code und Codex ein Layout. plugin.json bleibt geschlossen, mcp.json getrennt, Geheimnisse in Umgebungsvariablen, nicht in headers.

Zu frühes Einpacken kostet ein zu pflegendes Manifest und eine Review-Halluzination: „wir haben jetzt ein Plugin.“ Die Kiste macht aus einem Skill kein Werkzeug und gibt MCP keine Anleitung. Unabhängige Komponenten scheitern unabhängig: ein Server in mcp.json kann nicht starten, Skills laden weiter; ein kaputtes SKILL.md-Frontmatter reißt den Rest nicht mit. Das ist die Spez. Behandelt Ihre CI ein unbekanntes Top-Level-Feld als ganzen Paket-Abbruch, sind Sie strenger als der Client — wissen Sie das.

Die A2A-Linie noch einmal. Ein Plugin beantwortet, wie dieser Agent eine Gruppe Skills und Werkzeuge bekommt. Wie der Rechnungs-Agent eines anderen Teams gefunden wird, ist eine Agent Card, nicht ihn als ein Tool in Ihre mcp.json zu stopfen. Mehrfach-Klärung und asynchrone Callbacks sprengen eine Funktionsaufruf-Form. Ein Satz für die Reihenfolge: zuerst die Hand, dann die Anleitung, zuletzt die Kiste. Ein Plugin ohne Hand ist Kartons bestellen, bevor Sie wissen, was Sie verkaufen.

{
  "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
  "name": "reports-plugin",
  "version": "1.0.0",
  "description": "Invoice MCP plus the weekly-summary skill, shipped together"
}

Drei Schemas, drei Discoveries; in JSONVue prüfen

Verträge nach Hop ausbreiten. Erstens: plugin.schema.json — kann die Kiste gefunden werden; $schema auf https://agent-plugins.org/schemas/1.0.0/plugin.schema.json nageln. Zweitens: mcp.schema.json — wie verbinden; type muss explizit sein. Drittens: inputSchema jedes Werkzeugs — gehen Arguments durch. Skill-Frontmatter ist YAML, keines dieser drei; kein „JSON Schema“ über eine ganze SKILL.md. Discovery prüft die ersten zwei; Aufruf das dritte.

Mindestens fünf Fixtures: das Entscheidungsprotokoll oben, eine legale plugin.json, ein Manifest mit einem Extra-Top-Level-Feld, eine portable mcp.json, ein echtes tools/call-Arguments-Objekt. Das Protokoll fängt Streit zwischen den vier Fragen und choice. Manifeste fangen den Paketvertrag. Arguments fangen den Werkzeugvertrag. Developer Knowledge nutzt einen API-Key zur Client-Laufzeit; die mcp.json in Git soll keine Geheimnisse halten.

Im Browser reicht:JSON formatierenob Protokoll und beide Manifeste parsen;JSON-Schema prüfen$schema, name, mcpServers, inputSchema;JSON Diffportable mcp.json gegen einen client-nativen Export. Daten bleiben auf diesem Rechner. Weiter:MCP und JSON Schema, der Plugins-Überblick, und wie A2A und MCP die Arbeit teilen.

Verwandt: Google Agent Plugins 2026, MCP und JSON Schema, Was ist MCP, A2A vs MCP.

FAQ

Fazit und nächste Schritte

Die Wahl zwischen Skills, MCP und Plugins 2026 fällt auf einen Satz: brauchen Sie eine Hand, eine Anleitung, müssen beide zusammen reisen, installieren mehr als ein Client? Keine Drei-aus-eins-Wahl. Schichten, die stapeln.

Ausliefern in dieser Reihenfolge: die vier Antworten als Entscheidungs-JSON; wenn eine Hand nötig ist, zuerst inputSchema; wenn eine Anleitung nötig ist, zuerst description; leuchten beide und Sie kreuzen Clients, dann plugin.json. Die drei Verträge in JSONVue prüfen. Die Form der Kiste ist der Plugins-Überblick; das Leitungsprotokoll die MCP-Artikel; Agent-übergreifend der A2A-Artikel.