Agent skills versus MCP: de juiste interface kiezen
Agent skills versus MCP uitgelegd: vergelijk instructies, toolverbindingen, beveiligingsgrenzen, versioning en wanneer je beide combineert voor betrouwbare AI-agents.
De keuze tussen agent skills versus MCP wordt vaak voorgesteld als een wedstrijd tussen twee manieren om een AI “tools te geven”. Die voorstelling is onvolledig. Een skill en een Model Context Protocol-server lossen verschillende lagen van het probleem op: het ene leert een agent hoe die in een bepaald domein moet werken, terwijl het andere mogelijkheden en context via een gestandaardiseerde verbinding beschikbaar maakt.
Dockup gebruikt een SKILL.md, omdat de primaire interface een bestaande command-linetool is. De skill leert Claude Code en Codex hoe ze die CLI veilig gebruiken: altijd JSON opvragen, niet-interactief authenticeren, exacte targets bepalen, wachten op terminale deploymentstatussen en stoppen vóór destructieve acties.
Wat is een agent skill en waarom is SKILL.md belangrijk?
Een agent skill is een directory met werkinstructies en ondersteunende referenties die een agent kan laden wanneer een taak overeenkomt met het doel van de skill. SKILL.md is het startpunt: de frontmatter beschrijft de mogelijkheid en de hoofdtekst legt workflows, beperkingen, voorbeelden en beslisregels uit.
Een skill is vooral nuttig wanneer de uitvoerbare interface al bestaat. De agent heeft geen nieuwe protocoladapter nodig om een goed ontworpen CLI uit te voeren. De agent heeft nauwkeurige kennis nodig over:
- Welke commando’s leidend zijn.
- Welke flags vereist zijn voor gebruik door machines.
- Hoe authenticatie in een sandbox werkt.
- Welke outputs succes aantonen.
- Voor welke acties een mens nodig is.
- Waar secrets kunnen verschijnen.
- Hoe veelvoorkomende fouten worden gediagnosticeerd.
De installatie van Dockup is bewust eenvoudig:
npm install -g dockup-cli
dockup skill install
dockup skill status --json
Eén canonieke kopie wordt geschreven naar ~/.agents/skills/dockup/ en gelinkt naar zowel Claude Code als Codex. De skill wordt meegeleverd in het CLI-package en dockup update werkt beide samen bij. Die packagingkeuze voorkomt een veelvoorkomende foutmodus: instructies die commando’s beschrijven die het geïnstalleerde binary niet heeft.
De skill is niet de deploymentengine. De CLI voert bewerkingen uit, geeft JSON uit en retourneert exitcodes. De skill is de gebruikershandleiding die de agent volgt.
Wat is het Model Context Protocol?
Het Model Context Protocol, meestal MCP genoemd, is een open protocol om een AI-applicatie via een client-serverarchitectuur te verbinden met externe tools, resources en prompts. Een MCP-server kan aanroepbare tools, leesbare resources en herbruikbare prompts beschikbaar maken. Een MCP-client binnen de agenthost ontdekt en activeert deze mogelijkheden.
MCP is waardevol wanneer een systeem een duurzame protocolgrens nodig heeft in plaats van lokale shell-executie. Voorbeelden zijn:
- Een externe SaaS-API die zorgvuldig getypeerde bewerkingen beschikbaar moet maken.
- Een databron die doorzoekbare resources aanbiedt.
- Een desktopapplicatie die tool discovery wil bieden zonder een CLI mee te leveren.
- Een centrale service die door veel agenthosts en besturingssystemen wordt gebruikt.
- Een integratie waarbij de server credentials en policy moet beheren.
De server beheert de implementatie achter elke tool. De agenthost ziet de opgegeven naam, beschrijving, inputschema en output. Transport, lifecycle en autorisatie hangen af van de gekozen MCP-configuratie.
MCP biedt niet automatisch domeinoordeel. Een server kan delete_service beschikbaar maken, maar de agent heeft nog steeds policy nodig over wanneer verwijderen gepast is. Omgekeerd kan een skill een workflow uitleggen, maar geen mogelijkheden creëren die ontbreken in de onderliggende CLI of API.
Waarin verschillen agent skills versus MCP in de praktijk?
De duidelijkste vergelijking maak je op basis van verantwoordelijkheid:
| Dimensie | Agent skill / SKILL.md | MCP-server |
|---|---|---|
| Primaire taak | Workflows en beperkingen aanleren | Tools, resources en prompts beschikbaar maken |
| Uitvoering | Gebruikt bestaande CLI’s, bestanden, API’s of apps | Server implementeert aanroepbare mogelijkheden |
| Discovery | Agent laadt passende skillinstructies | Client ontdekt servermogelijkheden |
| Deployment | Vaak een directory die met een package wordt geïnstalleerd | Een lokaal of remote serverproces |
| Versierisico | Instructies kunnen afwijken van de tool | Serverschema kan afwijken van backendgedrag |
| Beste toepassing | Bestaande interface heeft deskundige werkinstructies nodig | Mogelijkheid heeft een gestandaardiseerde protocolgrens nodig |
| Beveiligingsfocus | Gedragsregels en commandoveiligheid | Verbinding, serververtrouwen, scopes en toolautorisatie |
| Offline/lokaal gebruik | Uitstekend met lokale CLI’s | Mogelijk met een lokale MCP-server |
| Hergebruik voor meerdere clients | Skill voor elke host kopiëren of packagen | Eén server kan meerdere compatibele clients ondersteunen |
Geen van beide kolommen is inherent meer “agentic”. Betrouwbaarheid ontstaat door de interface af te stemmen op het systeem.
Voor Dockup heeft de CLI al 135 commando’s, gestructureerde JSON, echte exitcodes, een standaard deploy-time-out van 900 seconden, het maskeren van secrets en bevestigingsgates. Elk commando in een andere lokale server wikkelen zou een vertaallaag toevoegen zonder de onderliggende deploymentwaarheid te veranderen. Een skill past hier direct, omdat deze de agent leert hoe die het bestaande executable contract gebruikt.
Een remote platform zonder CLI kan tot de tegenovergestelde conclusie komen. Een MCP-server kan het ontbrekende, getypeerde toollandschap bieden en API-credentials buiten de shellomgeving van de agent houden.
Wanneer gebruik je een skill, MCP of beide?
Gebruik alleen een skill wanneer aan alle volgende voorwaarden is voldaan:
- Een volwassen CLI of lokale applicatie biedt de vereiste mogelijkheden al.
- De agenthost deze mag uitvoeren.
- Machineleesbare output en exitsemantiek toereikend zijn.
- De belangrijkste leemte procedurele kennis is, niet connectiviteit.
- Packaging ervoor kan zorgen dat instructies op één lijn blijven met het executable.
Gebruik alleen MCP wanneer de agent een protocol-native verbinding nodig heeft en de server zelf voldoende context kan bieden voor veilige uitvoering. Dit komt vaak voor bij data access met veel leesbewerkingen, remote services en applicaties die een stabiele toolinterface voor verschillende clients willen.
Gebruik beide wanneer de protocoltools een uitgebreider operationeel draaiboek nodig hebben. Een MCP-server kan veilige, getypeerde primitives beschikbaar maken, terwijl een skill de meerstaps businessworkflow, escalatieregels en validatiecriteria uitlegt. De skill kan de agent vertellen wanneer en waarom elke MCP-tool moet worden aangeroepen.
Een gecombineerde architectuur kan er als volgt uitzien:
User request
↓
Skill: workflow, policy, validation rules
↓
MCP client: discovers typed capabilities
↓
MCP server: authenticates and executes
↓
External system
Een CLI-gecentreerde architectuur is eenvoudiger:
User request
↓
Skill: workflow, policy, validation rules
↓
CLI: JSON output + exit code + wait semantics
↓
Platform API
Complexiteit moet gerechtvaardigd worden door een grens die ermee verbetert. MCP toevoegen alleen omdat het populair is, kan een extra proces creëren dat je moet deployen, authenticeren, monitoren en versionen.
Voorbeelden van keuzes
| Situatie | Beste startpunt | Reden |
|---|---|---|
| Lokale deployment-CLI met JSON-output | Skill | Connectiviteit bestaat al |
| Bedrijfskennisbank met gestructureerde resources | MCP | Resource discovery staat centraal |
| API voor databasebeheer zonder CLI | MCP | Getypeerde remote bewerkingen zijn nuttig |
| Complex release-runbook over bestaande tools heen | Skill | De cross-toolprocedure is de belangrijkste behoefte |
| Gereguleerde remote bewerkingen plus gedetailleerde policy | Beide | Server handhaaft de scope; skill stuurt het gedrag |
| Eenmalige persoonlijke automatisering | Skill of directe CLI | De laagste operationele overhead |
Het juiste antwoord kan in de loop van de tijd veranderen. Een team kan beginnen met een skill rond een CLI en later een MCP-server toevoegen wanneer remote toegang voor meerdere clients of gecentraliseerd credentialbeheer belangrijk wordt.
Hoe verhouden security- en trust boundaries zich tot elkaar?
Skills zijn instructies, dus het risico dat ze vormen voor vertrouwen lijkt op dat van codedocumentatie met operationele invloed. Een kwaadwillige of onzorgvuldige skill kan een agent vertellen secrets vrij te geven, safeguards uit te schakelen of destructieve commando’s uit te voeren. Controleer de volledige directory, niet alleen de titel.
Vragen voor een skillreview zijn onder meer:
- Wie heeft de skill gepubliceerd?
- Roept deze commando’s aan buiten het opgegeven doel?
- Instrueert de skill de agent om tokens of credentials af te drukken?
- Omzeilt de skill confirmations?
- Zijn commandovoorbeelden afgeleid van de geïnstalleerde versie?
- Kunnen updates de skill vervangen zonder review?
- Definieert de skill een begrensd proces voor target discovery?
MCP introduceert een trust boundary rond de server. De client moet weten met welke server die verbinding maakt, welke tools deze beschikbaar maakt, welke data de machine verlaat en hoe autorisatie is afgebakend. Een server kan het gedrag achter een stabiele toolnaam wijzigen, dus provenance van de deployment en serverversioning zijn belangrijk.
Vragen voor een MCP-review zijn onder meer:
- Is de server lokaal of remote?
- Wie beheert de server?
- Hoe worden credentials opgeslagen en geroteerd?
- Welke tool calls kunnen data wijzigen of verwijderen?
- Worden toolinputs aan de serverkant gevalideerd?
- Worden outputs behandeld als niet-vertrouwde content?
- Is elke call auditeerbaar?
- Kan de client beschikbare tools beperken?
De agenthost mag “ontdekt via MCP” niet gelijkstellen aan “veilig”. Protocolstandaardisatie verbetert interoperabiliteit, niet de betrouwbaarheid van elke server.
De skill van Dockup bevat verschillende veiligheidsregels: gebruik DOCKUP_TOKEN in plaats van interactieve login, druk nooit credentials af, ontdek targets met dockup services --json, gebruik --wait en stop bij needs_confirm. De CLI versterkt deze instructies door secrets te maskeren en destructieve bewerkingen zonder expliciete goedkeuring te weigeren. Dit defense-in-depthmodel wordt beschreven in production guardrails for AI agents.
Hoe moeten versioning en fout recovery werken?
Version drift is bij beide benaderingen mogelijk, maar ziet er anders uit.
Een skill kan verouderd raken wanneer het gedocumenteerde commando verandert. De sterkste mitigatie is de skill samen met het executable te packagen en beide via één releaseproces te updaten. Dockup volgt dit model. De agent kan de geïnstalleerde skill controleren:
dockup skill status --json
Een update werkt de CLI en de meegeleverde skill samen bij:
dockup update
Een MCP-client kan de huidige toolschema’s van de server ontdekken, maar compatibiliteit van het schema garandeert geen semantische compatibiliteit. Een tool kan dezelfde inputs behouden en toch de autorisatie, side effects, latency of interpretatie van de output wijzigen. De server moet versies publiceren, waar mogelijk backward compatibility behouden en gestructureerde fouten retourneren.
Ook foutafhandeling verschilt. Een CLI biedt van nature proces-exitcodes. Een MCP-tool call heeft een even duidelijk resultaat op applicatieniveau nodig. In beide gevallen mag de agent succes niet afleiden uit een bevestiging op transportniveau.
Een nuttige checklist voor betrouwbaarheid is:
| Vereiste | Implementatie met skill + CLI | MCP-implementatie |
|---|---|---|
| Capability discovery | CLI-schema | Toollijst van de server |
| Gestructureerde output | JSON/NDJSON | Getypeerd toolresultaat |
| Foutsignaal | Niet-nul exitcode + code | Expliciet errorresultaat |
| Langdurige bewerking | --wait / gedocumenteerde stream | Progress- of completionprotocol |
| Bescherming van secrets | Masking en stderr-discipline | Redaction aan serverkant |
| Goedkeuring voor destructieve acties | CLI-confirmation gate | Serverpolicy of clientconfirmation |
| Audit | Platformauditlog | Auditlogs van server en backend |
| Versiecontrole | Skill-/binarystatus | Servermetadata en schema’s |
De interface moet het moeilijker maken om een foutief succes te rapporteren dan om succes correct te rapporteren.
Welke architectuur moet een productieteam kiezen?
Begin met het benoemen van de werkelijke leemte.
Kies voor een skill-firstarchitectuur wanneer het team al een CLI vertrouwt en beheert. Investeer in het machinecontract: JSON, echte exitcodes, stabiele foutcodes, versie-afgestemde instructies en confirmation. Package de skill vervolgens met die tool. Dit is de kortste route voor Claude Code deployment en Codex deployment via Dockup.
Kies voor MCP-first wanneer de mogelijkheid van nature remote, resourcegeoriënteerd of gedeeld door veel clients is. Behandel de server als productiesoftware: authenticeer deze, beperk de scope, monitor de server en review elke mutatie.
Kies voor beide wanneer policy en connectiviteit afzonderlijk complex zijn. Houd de verantwoordelijkheden duidelijk. De skill mag de serverimplementatie niet dupliceren en de serverbeschrijving mag geen uitgebreid operationeel handboek worden.
Een praktische evaluatieworkshop
Voer een kleine proof uit met één read-bewerking, één omkeerbare write, één langdurige bewerking en één destructieve bewerking die geblokkeerd moet worden. Beoordeel elk ontwerp op:
- Hoe de agent de bewerking ontdekt.
- Hoe credentials worden aangeleverd.
- Hoe succes wordt aangetoond.
- Hoe fouten worden gecategoriseerd.
- Hoe een mens gevaarlijke acties goedkeurt.
- Hoe logs en auditgegevens worden opgehaald.
- Hoe versies op één lijn blijven.
- Hoe de integratie netjes wordt verwijderd.
Neem geen beslissing op basis van alleen een diagram. Observeer de foutpaden. Een ontwerp dat op het happy path elegant lijkt, kan ambigu worden wanneer een deployment een time-out krijgt, een server de verbinding verbreekt of een instructiebestand één release achterloopt.
De Dockup CLI reference biedt een concreet voorbeeld van een skill-backed CLI-contract. Het bredere artikel over AI-powered development legt uit waarom deze interfaces belangrijk zijn nu agents een groter deel van de development loop overnemen.
Houd rekening met operationeel eigenaarschap
De eigenaar van de integratie is minstens zo belangrijk als de architectuur. Een skill rond een CLI erft meestal het installatie-, release- en supportproces van die CLI. Het team dat het binary publiceert, kan de bijbehorende instructies leveren en ze samen testen.
Een MCP-server creëert een afzonderlijk productiecomponent. Iemand moet verantwoordelijk zijn voor hosting, certificaten of het lokaal starten van processen, authenticatie, monitoring, incident response, schema compatibility en dependency updates. Die investering kan de moeite waard zijn wanneer de server een betekenisvolle gedeelde grens vormt. Het is onnodige overhead wanneer de server alleen lokale calls doorstuurt naar een executable die al voldoet.
Leg tijdens de evaluatie vast wie eigenaar is van elke laag:
| Laag | Eigenaar bij skill-first | Eigenaar bij MCP-first |
|---|---|---|
| Domeininstructies | Skillpublisher | Clientprompt of companion skill |
| Uitvoerbaar gedrag | CLI-publisher | MCP-serverteam |
| Credentialbeheer | CLI en runtimeomgeving | Server en clientverbinding |
| Beschikbaarheid | Lokaal executable en platform-API | Serverproces, transport en backend |
| Schema compatibility | CLI-releaseproces | MCP-serverreleaseproces |
| Incidentgegevens | CLI-output en platformaudit | Clientlogs, serverlogs en backendaudit |
Deze ownershiptabel maakt het debat over agent skills versus MCP vaak duidelijker dan een featurechecklist.
Evalueer latency en foutoppervlakken
Een lokale skill plus CLI-call heeft een korte route: agenthost, proces, platform-API. Een MCP-route kan het starten van de server, transportonderhandeling, remote routing en een extra authenticatielaag toevoegen. Die toevoegingen zijn niet per definitie slecht, maar elk ervan creëert een afzonderlijk foutoppervlak.
Test verbroken verbindingen, verlopen credentials, ongeldige inputs, gedeeltelijke langdurige bewerkingen en serverupdates. De agent moet kunnen aangeven of de fout in de host, de protocolverbinding, de server of het externe platform is opgetreden. Een generiek resultaat als “tool failed” volstaat niet voor productiewerk.
Bij langdurige deployments moet de interface terminal-state-semantics behouden. Of de call nu een CLI-actie met --wait is of een MCP-tool met progress, de agent mag een acknowledgment niet omzetten in succes. De keuze tussen agent skills versus MCP neemt die vereiste niet weg.
Plan voor portability zonder de waarheid op te offeren
MCP kan portability tussen compatibele clients verbeteren, omdat dezelfde server tools via een gedeeld protocol adverteert. Skills kunnen ook portable zijn wanneer meerdere agents dezelfde directory- en SKILL.md-conventies ondersteunen, zoals Claude Code en Codex doen voor het installatiemodel van Dockup.
Portability is alleen nuttig wanneer de semantiek nauwkeurig blijft. Een tool met de naam deploy moet definiëren of deze terugkeert wanneer de deployment in de wachtrij staat of wanneer deze healthy is. Een skillinstructie die zegt “deploy and verify” moet verwijzen naar een commando dat dat bewijs daadwerkelijk kan leveren.
Het sterkste ontwerp houdt domeinwaarheid dicht bij de executable-laag en gebruikt de hogere laag om intentie uit te leggen. In de vergelijking agent skills versus MCP kan noch een gestandaardiseerd protocol noch een goed geschreven instructiebestand compenseren voor een ambigue backendbewerking.
Breng de workflow naar productie
Gebruik de kleinst mogelijke architectuur die een betrouwbare grens creëert. Installeer voor Dockup de meegeleverde skill en laat de CLI de uitvoerbare bron van deploymentwaarheid blijven.
npm install -g dockup-cli
dockup skill install
Het eerste commando installeert de CLI. Het tweede installeert de bijbehorende Dockup-skill voor Claude Code en Codex. Begin gratis op app.dockup.ai.
FAQ
Zijn agent skills en MCP hetzelfde?
Nee. Een skill biedt voornamelijk instructies en operationele kennis. MCP biedt een protocol om tools, resources en prompts via een client-serververbinding beschikbaar te maken.
Voert een SKILL.md-bestand zelf commando’s uit?
Nee. Het vertelt de agent hoe die onderliggende mogelijkheden zoals een CLI, bestanden, API’s of MCP-tools gebruikt. De uitvoerbare interface voert de actie uit.
Wanneer is een skill beter dan MCP?
Een skill is vaak de eenvoudigere keuze wanneer een volwassen lokale CLI al veilige, machineleesbare bewerkingen biedt en workflowbegeleiding het ontbrekende onderdeel is.
Kan een agent een skill en MCP samen gebruiken?
Ja. Een skill kan een meerstapsworkflow en policy beschrijven, terwijl een MCP-server de getypeerde tools en resources beschikbaar maakt die in die workflow worden gebruikt.
Waarom levert Dockup zijn skill mee in het CLI-package?
Door ze samen te packagen kan dockup update het executable en de bijbehorende instructies in één keer vernieuwen. Zo wordt het risico kleiner dat de skill een andere commandoversie beschrijft.