Procedures horen niet permanent in de prompt, privileges evenmin

Name: Djimit
Address: NL

Waarom @skills een sterk protocolidee bevat, maar padgebaseerde procedurekennis nog geen betrouwbare, veilige of soevereine enterprise capability vormt

Executive thesis

Het paper "@skills: Attention Is All You Have" identificeert een reële architectuurfout in de huidige generatie agent skills. Installatie koppelt drie functies die verschillende levenscycli en trust requirements hebben:

het beschikbaar maken van procedurele inhoud;
het bewaren en aanpassen van die inhoud;
het automatisch activeren van die inhoud zonder expliciet verzoek.

Alleen de derde functie vereist dat skillmetadata permanent in de prompt aanwezig is. De kernbijdrage van het paper is daarom niet de slogan dat agents "minder dan honderd skills" aankunnen, maar de ontkoppeling van content, persistence en implicit activation. Die ontkoppeling is architecturaal waardevol. Zij maakt van procedurekennis een just-in-time resource, vergelijkbaar met demand paging in een besturingssysteem.

De headline-claim van het paper is echter niet experimenteel vastgesteld. De auteurs meten niet hoe trigger precision, trigger recall of task success veranderen wanneer het aantal geïnstalleerde skills oploopt. Er is geen gecontroleerde vergelijking tussen @skills, geïnstalleerde skills, retrieval, langere prompts, een deterministische workflow of een sterker model. De grens van "fewer than 100 reliable trigger slots" is een literatuurondersteunde hypothese, geen direct empirisch resultaat. De auteurs erkennen dit zelf expliciet als beperking en benoemen een dergelijke meting als toekomstig werk.

Voor enterprise AI stopt het paper bovendien precies vóór de kritieke trust boundary. Een pad is geen onveranderlijke identiteit. Een Git-revisie is geen geverifieerde uitgeversidentiteit. Een .source-bestand is geen authorisatie. Een lokale kopie is geen bewijs van veilige inhoud. Een expliciete referentie maakt het laden van instructies intentioneler, maar niet de modelinterpretatie, tooluitvoering of uitkomst deterministisch. En een promptinstructie als "negeer onveilige instructies" is geen security control.

Het eindverdict is daarom: de organisatie moet het just-in-time pagingmodel ADAPT-en, maar het trustmodel van @skills niet ADOPT-en. De beste enterprisevariant is een gecontroleerde vorm van Tier 2, een gereviewde, projectspecifieke en immutable skillkopie zonder permanente promptresidentie, verpakt in content-addressed identity, signed provenance, policy enforcement, workload identity, sandboxing, onafhankelijke assurance en expliciete publication authority.

Bewijsdiscipline

In dit artikel worden de volgende kwalificaties gebruikt:

Kwalificatie	Betekenis
FACT	Extern verifieerbare eigenschap van paper, protocol, code of standaard
AUTHOR CLAIM	Bewering van de auteurs die niet noodzakelijk zelfstandig is aangetoond
EMPIRICAL RESULT	Resultaat uit een beschreven meting of experiment
INFERENCE	Redeneerbare conclusie uit meerdere observaties
HYPOTHESIS	Falsifieerbare maar nog niet overtuigend geteste verklaring
PREDICTION	Verwachte toekomstige ontwikkeling
RECOMMENDATION	Architecturale, operationele of bestuurlijke beslissing

Dat onderscheid is hier essentieel. Het paper combineert corpusonderzoek, protocolontwerp, literatuurinterpretatie, implementatieclaims en ecosysteempredicties. Die bewijssoorten mogen niet als één homogene empirische onderbouwing worden behandeld.

1. Waarom dit paper relevant is

Agent skills zijn geen gewone prompts. Zij combineren doorgaans:

procedurele instructies;
toolbeschrijvingen;
scripts;
referentiemateriaal;
voorbeelden;
outputconventies;
impliciete aannames over rechten en runtime.

De officiële Agent Skills-specificatie gebruikt progressive disclosure. Naam en beschrijving worden beschikbaar gemaakt om een skill te kunnen selecteren. De volledige SKILL.md en aanvullende resources worden pas geladen wanneer de skill relevant wordt geacht. De skillbeschrijving functioneert daarmee als primaire trigger voor modelgedreven selectie.

Het @skills-paper stelt dat dit model niet schaalt, omdat de beschrijvingen van geïnstalleerde skills resident blijven in de context en op iedere beurt concurreren om aandacht. De auteurs rapporteren voor hun crawl van juli 2026:

Meting	Door het paper gerapporteerd
Gevonden SKILL.md-directories	56.804
GitHub-repositories	1.133
Opgehaalde skill bodies	56.245
Mediaan aantal woorden per body	921
90e percentiel	2.207 woorden
Gemiddelde	1.159 woorden
Geschatte mediane omvang	circa 1.200 tot 3.700 tokens
Geschatte omvang bij p90	circa 2.900 tot 8.800 tokens
Eerste twee aggregator-repositories	circa 21 procent van het corpus
Eerste vijftien repositories	circa 51 procent van het corpus

De auteurs vonden daarnaast 958 first-party skills bij 21 providerorganisaties. In een deelanalyse van 569 skills uit vijftien providerrepositories verwees volgens hun heuristiek 79 procent naar een provider-CLI of API en bevatte 60 procent shellblokken. In een bredere steekproef vereiste 42 procent een extern account en verpakte nog eens 26 procent een gratis tool. De auteurs presenteren deze providerpercentages terecht als bovengrenzen, omdat substring- en structurele heuristieken false positives kunnen bevatten.

Deze cijfers rechtvaardigen twee conclusies, maar niet meer dan dat:

EMPIRICAL RESULT: het openbare skill-ecosysteem is groot, gefragmenteerd en sterk geconcentreerd in enkele verzamelrepositories.
INFERENCE: een model waarbij iedere beschikbare skill permanent als beschrijving in de prompt staat, kan onmogelijk de volledige publieke long tail ontsluiten.

De cijfers rechtvaardigen niet automatisch de conclusie dat er 56.804 unieke, bruikbare of veilige capabilities bestaan. De meeteenheid is een directory met een SKILL.md, niet een semantisch unieke en gevalideerde procedure. Forks, duplicaten, gegenereerde varianten, bundels en aggregatorcopies vergroten de telling.

Dat onderscheid is bestuurlijk relevant. Een grote artifactvoorraad is nog geen grote capabilityvoorraad. Een capability ontstaat pas wanneer de procedure:

relevant wordt geselecteerd;
correct wordt geïnterpreteerd;
over geautoriseerde tools beschikt;
veilig kan worden uitgevoerd;
een valide uitkomst produceert;
onafhankelijk kan worden geverifieerd.

2. Het probleem dat de auteurs daadwerkelijk proberen op te lossen

De onderzoeksvraag kan preciezer worden geformuleerd als: hoe kan een agent toegang krijgen tot een zeer grote collectie procedurele kennis, zonder dat iedere procedure permanent promptcapaciteit verbruikt en zonder dat gebruik altijd een traditionele installatie vereist?

De auteurs stellen dat het huidige installatiemodel drie orthogonale beslissingen ten onrechte samenvoegt:

installatie = content delivery + persistence + automatic triggering

Maar alleen automatic triggering vereist resident metadata:

prompt residency leidt tot implicit discoverability

Content kan op het gebruiksmoment worden gelezen. Persistence kan door het bestandssysteem en Git worden geleverd. Het model hoeft een skill alleen permanent te kennen wanneer het die skill zelfstandig en zonder expliciete aanwijzing moet activeren.

Dit is het sterkste gedeelte van het paper. Het is een klassieke separation-of-concerns-correctie:

artifact distribution hoort niet in de prompt;
version ownership hoort niet in de prompt;
activation policy hoort niet uitsluitend in de prompt;
tool authority hoort zeker niet in de prompt.

De schaarste waarop het paper wijst bestaat bovendien uit vier verschillende schaarsten die niet mogen worden samengevoegd:

Nominale contextcapaciteit, het maximale aantal tokens dat technisch kan worden aangeboden.
Effectieve aandachtscapaciteit, hoeveel informatie het model betrouwbaar kan gebruiken.
Instruction-selection-capaciteit, hoeveel beschrijvingen het model betrouwbaar tegen een taak kan matchen.
Economische capaciteit, hoeveel inputtokens, latency en inferencekosten aanvaardbaar zijn.

Een model kan een contextwindow van honderdduizenden tokens ondersteunen en toch slecht zijn in het selecteren van één relevante instructie uit honderden concurrerende beschrijvingen. Meer context is daarom niet hetzelfde als meer bestuurbare aandacht.

3. Reconstructie van het onderzoeksmodel

Het paper is primair een systems and protocol design paper, geen klassiek machine-learningexperiment.

Onderzoekscomponent	Reconstructie
Onderzoeksvraag	Hoe kan procedurele agentkennis worden ontsloten zonder permanente installatie en promptresidentie?
Hypothese	Alleen implicit activation vereist resident metadata; content en persistence kunnen just-in-time worden geleverd.
Onderzoeksobject	Publieke SKILL.md-ecosystemen en skill delivery mechanisms
Architectuur	Drie delivery tiers: reference, save en install
Algorithmische kern	Padresolutie, local-first lookup, validating cache, vendoring, autotriggerregels
Training	Geen modeltraining
Modellen	Geen modellen systematisch geëvalueerd
Inference-experiment	Niet uitgevoerd
Dataset	Een eenmalige crawl van openbare GitHub-repositories in juli 2026
Baseline	Conceptueel install-only, niet experimenteel vergeleken
Ablations	Geen
Primaire metrics	Aantallen skills, repositories, omvang, typen, resident token estimates
Task-success-metrics	Geen
Trigger precision/recall	Niet gemeten
Latency	Niet gemeten
Totale tokenkosten	Niet end-to-end gemeten
Compute en energie	Niet gerapporteerd
Variance en confidence intervals	Alleen grove steekproefonzekerheid bij corpusclassificatie
Reproduceerbaarheid corpus	Beperkt, de geïnspecteerde officiële repository bevat geen overeenkomstige openbare crawlset of evaluatiepipeline
Implementatie	TypeScript-referentie-implementatie en agentinstructiebestand

De officiële repository beschrijft een Node/TypeScript-package, versie 0.1.0, met Node 18 als minimale versie en een beperkte runtime dependency set. De repository bevat protocolcode, tests en documentatie, maar in de geïnspecteerde toestand geen formeel gepubliceerd release-artifact en geen GitHub Actions-workflow in .github. De protocolstatus wordt desalniettemin als stable omschreven. Dat bewijst implementatie-activiteit, maar niet production readiness.

4. Hoe het mechanisme technisch werkt

4.1 Tier 1, expliciete reference

Een skill wordt op het gebruiksmoment genoemd:

@skills:gh:owner/repository/path

De client resolveert het pad, haalt de inhoud op en maakt deze beschikbaar in de context van de actuele taak. Er blijft geen permanente triggerbeschrijving achter.

MECHANISM: procedurele inhoud wordt dicht bij de taak in de context geplaatst.
OBSERVED EFFECT: de skillbeschrijving hoeft niet permanent resident te zijn.
AUTHORS' INTERPRETATION: de long tail wordt bruikbaar zonder installatietax.

De eerste twee uitspraken volgen uit de architectuur. De derde vereist gebruiks- en task-success-data die het paper niet levert.

4.2 Tier 2, save

De suffix :save kopieert de skill naar een Git-tracked .atskills/-directory in het project. Een .source-bestand legt bron en revisie vast. Een opgeslagen kopie wordt losgekoppeld van upstream en kan lokaal worden aangepast.

De save-logica probeert conflicten te vermijden. Een onveranderde kopie kan worden vervangen; een lokaal gewijzigde kopie wordt niet stilzwijgend overschreven. Dit is een bruikbaar ownershipmodel voor teamprocedures.

Voor enterprisegebruik is dit de meest waardevolle tier, maar alleen nadat vier aanpassingen zijn toegevoegd:

pinning op een immutable digest;
geverifieerde issuer identity;
formele admission status;
scheiding tussen skillinhoud en runtime authority.

4.3 Tier 3, install of autotrigger

De suffix :install voegt een regel toe aan .atskills/.autotrigger. De syntax volgt glob- en gitignoreachtige conventies. Alleen de geselecteerde frontmatter wordt resident. De body blijft progressive disclosure gebruiken.

De paperarchitectuur maakt hiermee twee beslissingen onafhankelijk:

own_copy in {0,1}
implicit_activation in {0,1}

Daardoor ontstaan vier toestanden:

Local ownership	Implicit activation	Betekenis
0	0	Eenmalige remote reference
1	0	Projectspecifieke, expliciet aangeroepen procedure
0	1	Upstream skill met automatische trigger
1	1	Lokale skill met automatische trigger

Het bestaande installatiemodel biedt hoofdzakelijk de laatste twee toestanden, waarbij beschikbaarheid en implicit activation worden gekoppeld.

4.4 Resolver en validating cache

De actuele referentie-implementatie gebruikt expliciete namespaces:

een kaal pad is uitsluitend lokaal;
hub: verwijst naar de hub;
gh: verwijst naar GitHub.

De prefix bepaalt daarmee de source class. Cloudreferenties worden alsnog local-first afgehandeld, omdat een lokaal opgeslagen kopie op hetzelfde logische pad de remote variant kan overschrijven. Daarna volgt een machinebrede cache en zo nodig een remote fetch. Een revision probe controleert of upstream gewijzigd is; offline kan een stale cache worden gebruikt met een waarschuwing.

Deze logica levert eenvoud, maar geen referential transparency:

resolve(path, project_A) != resolve(path, project_B)

wanneer één project een lokale shadowcopy bevat en het andere niet. Een pad is daarmee een contextafhankelijke logische naam, niet de onveranderlijke identiteit van de uitgevoerde bytes.

4.5 Directory als menu

Wanneer een pad geen individuele SKILL.md aanwijst maar een directory, wordt de directory als skillmenu behandeld. De gebruiker of agent kan vervolgens een of meer onderliggende skills kiezen. De implementatie beperkt een collectie tot 128 skills om excessieve downloads en contextoverbelasting te voorkomen. Die grens is een engineering guardrail, geen experimenteel gevalideerde cognitieve constante.

5. De protocolarchitectuur als state machine

Een minimale reconstructie van het paper ziet er als volgt uit:

REFERENCE
   ↓
NORMALISE PATH
   ↓
CHECK LOCAL COPY
   ↓
CHECK CACHE
   ↓
PROBE OR FETCH REMOTE
   ↓
LOAD MENU OR SKILL
   ↓
INJECT INTO TASK CONTEXT
   ↓
MODEL INTERPRETS PROCEDURE
   ↓
MODEL MAY CALL TOOLS

Dit model omvat resolutie en contextlevering, maar niet de volledige enterprise control flow. Een veilige architectuur vereist ten minste:

DISCOVER
   ↓
RESOLVE
   ↓
VERIFY IDENTITY AND DIGEST
   ↓
CHECK REVOCATION
   ↓
CLASSIFY RISK
   ↓
ADMIT ARTIFACT
   ↓
MOUNT READ-ONLY
   ↓
LOAD AS UNTRUSTED PROCEDURAL INPUT
   ↓
MODEL PROPOSES ACTION
   ↓
POLICY AUTHORISES ACTION
   ↓
TOOL EXECUTES ACTION
   ↓
DETERMINISTIC VALIDATION
   ↓
INDEPENDENT ASSURANCE
   ↓
AUDIT, OBSERVE, REVOKE

Het paper specificeert hoofdzakelijk de eerste, tweede en gedeeltelijk de zesde stap. De overige stappen zijn niet optioneel voor enterprisegebruik.

6. Proposition-level beoordeling

ID	Proposition, inclusief conditie en scope	Ondersteunende evidence	Tegenevidence of onzekerheid	Status
P1	Geïnstalleerde skillbeschrijvingen verbruiken op iedere beurt resident context, wanneer de agent deze descriptors permanent in de systeemprompt plaatst.	Protocolbeschrijving, officiële progressive-disclosure-opzet en tokenmetingen.	Niet iedere toekomstige harness hoeft dezelfde implementatie te gebruiken.	SUPPORTED
P2	Content en persistence kunnen van implicit activation worden gescheiden zonder SKILL.md te wijzigen.	De referentie-implementatie realiseert reference, save en autotrigger als aparte functies.	Bewijst nog geen betere task success.	SUPPORTED
P3	Een agent beschikt over minder dan honderd betrouwbare auto-trigger slots.	Indirecte literatuur over instruction dilution, position effects en lange context.	Geen gecontroleerde skill-triggerproef, modelafhankelijkheid onbekend, geen precision/recall.	UNDETERMINED
P4	Expliciete referenties maken het combineren van N skills deterministisch.	De resolver kan N genoemde artifacts laden.	Selectie, modelcompliance, tooluitvoering en uitkomst blijven probabilistisch.	PARTIALLY_SUPPORTED
P5	Het pad is de identiteit van een skill.	Het pad is een stabiele logische referentie binnen de grammar.	Mutable upstream, local-first shadowing en verschillende projectstates laten hetzelfde pad naar andere bytes verwijzen.	CONTRADICTED als immutable artifact identity
P6	Version pinning is onwenselijk omdat providerdocumentatie met de dienst moet meebewegen.	Een frozen procedure kan incompatibel raken met een veranderende API.	Automatisch volgen maakt gereviewde en uitgevoerde inhoud verschillend, introduceert update drift en rug-pull-risico.	UNDETERMINED algemeen, CONTRADICTED voor geprivilegieerde productie
P7	.source levert voldoende provenance voor opgeslagen skills.	Het registreert bron en revisie en ondersteunt vergelijking.	Geen geverifieerde issuer, signature, trust policy, revocation of authorisation.	PARTIALLY_SUPPORTED
P8	Referencing is veiliger dan installeren.	Minder achtergrondskills in de prompt kan resident injection en onbedoelde triggering verminderen.	Remote just-in-time fetch introduceert mutable supply chain, typo, discovery en time-of-check/time-of-use risico.	UNDETERMINED
P9	Usage per reference stimuleert auteurs meer dan installcounts.	Economisch plausibele analogie met gebruiksmeting.	Geen longitudinale adoption- of authoringdata.	HYPOTHESIS
P10	@skills verbetert de agency van agents.	Procedures worden makkelijker beschikbaar en combineerbaar.	Planning, delegation, recovery, termination en tool success zijn niet getest.	UNDETERMINED

De propositietabel maakt duidelijk dat de engineeringconstructie sterker is onderbouwd dan de cognitieve en economische claims.

7. Wat de experimenten daadwerkelijk aantonen

Strikt genomen bevat het paper drie bewijssoorten.

7.1 Een corpusmeting

De crawl ondersteunt dat het publieke ecosysteem groot genoeg is om naïeve volledige promptresidentie onmogelijk te maken. Ook ondersteunt zij dat skills niet alleen lokale coding tricks zijn, maar providerintegraties, teamprocedures, creatieve workflows en domeinkennis bevatten.

Maar de semantische classificatie is gebaseerd op een uniforme steekproef van honderd skills. Voor een binaire proportie met n=100 is de maximale 95-procent-marge bij eenvoudige random sampling ongeveer 9,8 procentpunt. De categoriepercentages ondersteunen dus brede patronen, geen fijnmazige marktverhoudingen.

Daarnaast gelden vijf representativiteitsbeperkingen:

De crawl is een snapshot uit juli 2026.
GitHub-repositories representeren private enterprise skills niet.
Directorytelling verwijdert niet noodzakelijk semantische duplicaten.
Grote aggregators beïnvloeden de verdeling sterk.
Beschikbaarheid zegt niets over kwaliteit, veiligheid, onderhoud of daadwerkelijk gebruik.

7.2 Een literatuurgebaseerd mechanisme

De auteurs verbinden drie bekende verschijnselen:

positional degradation over lange contexten;
verslechtering door irrelevante of extra context;
lagere instruction-following-prestaties bij meer gelijktijdige instructies.

Deze literatuur ondersteunt directioneel dat resident skilldescriptions niet gratis zijn. Zij bepaalt echter niet het specifieke omslagpunt voor agent-skill-triggering.

Het paper gebruikt onder meer onderzoek waarin modellen tientallen tot honderden gelijktijdige constraints moeten volgen. Dat is gerelateerd, maar niet identiek aan een agent die tussen skillbeschrijvingen moet kiezen. Een exact keywordconstraintprobleem meet andere cognitieve operaties dan intent matching, procedural relevance en tool routing.

7.3 Een werkende referentie-implementatie

De implementatie laat zien dat het protocol technisch realiseerbaar is. Dat ondersteunt claims over:

grammar parsing;
path normalisation;
local-first resolution;
caching;
save semantics;
autotriggerbeheer;
directorymenu's.

Maar unit- en integratietests van een resolver zijn geen bewijs voor:

hogere task success;
lagere end-to-end latency;
lagere total cost;
betere skill discovery;
hogere beveiliging;
betrouwbaardere multi-skill workflows;
production-grade governance.

De repository laat bovendien zien dat de grammar en resolver rond de publicatiedatum nog actief werden gestabiliseerd. Een vroege wijziging verplaatste de cache uit een locatie die kon samenvallen met een projectroot. Een andere wijziging verving contextafhankelijke broninterpretatie door het principe "the prefix decides". Na indiening van het paper werd hostnamevalidatie aangescherpt omdat namen zoals evil-github.com of github.com.attacker.net eerder foutief als GitHubreferentie konden worden geïnterpreteerd.

Deze defecten invalideren het protocolidee niet. Ze tonen wel dat een eenvoudige path grammar zelf een security-critical parser en supply-chain boundary wordt.

8. Welke conclusie resteert zonder de auteursinterpretatie?

Wanneer uitsluitend naar de resultaten wordt gekeken, zonder de narratieve interpretatie van de auteurs, volgt:

Het publieke skill-ecosysteem is omvangrijk en gefragmenteerd. Skill bodies zijn te groot om volledig resident te maken. Zelfs compacte descriptors veroorzaken cumulatieve contextkosten. Een path-based protocol kan content, local ownership en auto-triggering technisch loskoppelen.

Niet aangetoond zijn:

dat honderd een algemene harde of zachte capaciteitsgrens is;
dat expliciete references vaker tot correcte uitvoering leiden;
dat @skills bestaande retrievalmethoden verslaat;
dat gebruikers de juiste paden kennen;
dat multi-skill tasks betrouwbaarder worden voltooid;
dat de totale latency afneemt;
dat de totale kosten dalen;
dat security verbetert;
dat auteurs meer publiceren;
dat de aanpak buiten coding agents generaliseert.

Dat is geen kleine nuance. Het verschil is dat het paper een goed gemotiveerd protocolontwerp biedt, maar geen gevalideerde performance theory.

9. Wat de resultaten niet aantonen

9.1 Geen directe slot-capaciteitsmeting

De paperclaim "fewer than 100 reliable trigger slots" heeft geen beschreven:

sample size;
taskset;
modelmatrix;
agent-harnessmatrix;
aantal runs;
variance;
confidence interval;
trigger precision;
trigger recall;
false-positive-rate;
false-negative-rate.

De claim is daarom een testbare hypothese, niet een empirical result.

Bovendien is een algemene capaciteit theoretisch onwaarschijnlijk. Triggerbetrouwbaarheid zal waarschijnlijk afhangen van het model, de agent harness, het aantal descriptors, de descriptorlengte, de semantische overlap tussen descriptors, de positie en ordering, het aantal conversatiebeurten en de duidelijkheid van de user query. Een verzameling van honderd onderling onderscheidbare skills kan betrouwbaarder zijn dan twintig vrijwel identieke skills met overlappende triggerbeschrijvingen.

9.2 Geen taakprestatievergelijking

Het paper vergelijkt niet:

installed progressive disclosure;
explicit @skills;
retrieval-based skill selection;
full-context loading;
deterministic workflow.

Daarom is niet vastgesteld of de voorgestelde architectuur de kwaliteit verhoogt of uitsluitend de plaatsing van context verandert.

9.3 Geen latencyanalyse

Een just-in-time remote fetch kan het resident tokenvolume verlagen, maar introduceert:

DNS- en netwerkafhankelijkheid;
repository lookup;
revision probes;
cache misses;
cloning of tree listing;
malware scanning;
signatureverificatie;
policy evaluation;
sandboxinitialisatie.

Zonder p50-, p95- en p99-metingen kan geen latencyvoordeel worden geclaimd.

9.4 Geen securityexperiment

Het paper erkent dat een remote skill een indirect prompt-injectionkanaal is. Het stelt dat provenance en review belangrijker zijn dan filtering, maar operationaliseert geen uitgeversidentiteit, signature policy, permission manifest, malware-evaluatie, sandbox of revocation channel.

9.5 Geen evaluatorbias in de klassieke zin, maar ook geen end-task verifier

Het paper is niet afhankelijk van een LLM-as-judge voor een grote task benchmark. Daardoor is correlated judge bias geen primaire bedreiging voor de corpuscijfers.

Het omgekeerde probleem is echter aanwezig: er is helemaal geen onafhankelijke task-level verifier voor de centrale performanceclaims. Daardoor kan niet worden vastgesteld of het protocol betere eindresultaten oplevert.

10. De sterkste bijdrage

De sterkste bijdrage is de decompositie:

procedure beschikbaar != procedure persistent != procedure automatisch actief

Deze decompositie corrigeert een diepere architectuurfout in agentplatforms. Resident skill descriptions zijn in feite control-plane state vermomd als prompttekst.

Dat is problematisch omdat prompttekst:

probabilistisch wordt geïnterpreteerd;
niet type-safe is;
geen formele lifecycle heeft;
moeilijk te revoken is;
geen betrouwbare authorisation semantics heeft;
gevoelig is voor contextinterferentie;
meestal niet onafhankelijk wordt geaudit.

De analogie met virtual memory is daarom bruikbaar:

Operating-systemconcept	Agentisch equivalent
RAM	Actieve context
Storage	Skill registry of repository
Page table	Capability registry en resolver
Page fault	On-demand skill load
Access bits	Policy en authorisation
Read-only page	Immutable skill mount
Process isolation	Agent sandbox
Kernel	Deterministische control plane

Het paper introduceert vooral een pagingsmechanisme. Het levert nog geen kernel. Dat maakt de paperbijdrage tegelijk sterk en begrensd. De auteurs lossen distributie en residentie op, niet trust, authority, execution isolation of assurance.

11. De sterkste kritiek

De sterkste kritiek is de stelling "the path is the identity". Een pad kan drie rollen vervullen:

een locator;
een logische naam;
een immutable artifact identity.

@skills levert voornamelijk de eerste twee. Neem:

@skills:gh:acme/security/deployment

Dit pad kan op verschillende momenten of in verschillende projecten verwijzen naar:

een gewijzigde upstream branch;
een andere Git commit;
een lokale vendored kopie;
een lokaal gewijzigde kopie;
een stale cache;
een inmiddels ingetrokken versie.

Daarom geldt: logical path is niet gelijk aan artifact identity. Een bruikbare enterprise-identiteit heeft minimaal de vorm:

SkillRef = (namespace, name, digest, issuer, policy channel)

Voor de organisatie kan dat bijvoorbeeld worden:

urn:djimit:skill:publisher/name@sha256:digest

Aangevuld met:

issuer: did:web:registry.djimit.nl
upstream_source: gh:owner/repository/path
upstream_revision: commit
channel: approved
risk_tier: L1
admission_decision: decision-id
revocation_state: active

Dit ontwerp laat het gebruiksvriendelijke logische pad bestaan, maar resolveert het vóór uitvoering naar een immutable en beleidsmatig toegelaten artifact.

Waarom de afwijzing van pinning niet overtuigt

Het paper heeft een valide tegenargument tegen blind pinnen. Een procedure die een veranderende SaaS-API beschrijft kan functioneel verouderen wanneer zij permanent bevroren blijft.

Maar daaruit volgt niet dat productie altijd de nieuwste upstreaminhoud moet uitvoeren. De juiste oplossing is een dual-channel-model:

upstream/latest
   ↓ discovery and candidate testing
candidate/<digest>
   ↓ security, compatibility and quality evaluation
approved/<digest>
   ↓ controlled production
revoked/<digest>

Daarmee worden actualiteit en controle niet als tegenpolen behandeld. Een nieuwe versie kan snel worden gevonden en getest, zonder dat zij automatisch de eerder goedgekeurde productieversie vervangt. Een mutable "latest" is geschikt voor discovery. Het is ongeschikt als authority-bearing productieartifact.

12. Steelman van het paper

De kritiek mag het kernprobleem niet wegredeneren.

De auteurs hebben gelijk dat traditionele package-managementconcepten niet automatisch naar iedere skill hoeven te worden gekopieerd. Een SKILL.md is vaak vooral leesbare procedurekennis. Een zwaar registryprotocol, complexe manifesten en agent-specifieke installatieformaten kunnen interoperabiliteit verminderen en de toegang voor niet-programmeurs verslechteren.

Ook zijn de volgende ontwerpkeuzes sterk:

het bestaande skillformaat blijft intact;
expliciete references sluiten aan op bestaande @-interacties;
lokale procedures kunnen via Git worden gereviewd;
private teamkennis krijgt hetzelfde deliverymodel als publieke kennis;
skills kunnen zonder permanente residentie worden uitgeprobeerd;
meerdere bronnen kunnen binnen één taak worden gecombineerd;
save en autotrigger zijn orthogonale beslissingen;
de triggerconfiguratie is zichtbaar als een diffbaar bestand;
de protocolimplementatie blijft relatief klein.

Voor exploratief, lokaal en low-risk gebruik kan deze eenvoud belangrijker zijn dan een volledig enterprise package-managementsysteem.

De legitieme kritiek is daarom niet dat @skills te eenvoudig is. De kritiek is dat dezelfde eenvoud niet als voldoende trustmodel voor geprivilegieerde enterprise-uitvoering mag worden geïnterpreteerd. De beste adaptation voegt een externe security envelope toe zonder SKILL.md zelf te forken.

13. Falsificatie en alternatieve verklaringen

13.1 Wat zou de slot-thesis weerleggen?

De thesis van minder dan honderd betrouwbare slots wordt verzwakt of weerlegd wanneer gecontroleerde experimenten aantonen dat moderne agents bij bijvoorbeeld 100, 200 of 500 descriptors:

stabiele trigger precision en recall behouden;
geen relevante task-success-regressie vertonen;
verschillende descriptorposities robuust verwerken;
dezelfde prestaties over lange multi-turn-sessies behouden;
geen disproportionele latency- of tokenkosten veroorzaken.

Een valide experiment moet descriptorlengte, semantische overlap, ordering, model, harness en conversation length controleren.

13.2 Kan schaal in plaats van architectuur het effect verklaren?

Ja. Een sterker model kan grotere descriptorcollecties mogelijk beter verwerken. Een model met betere routingtraining kan het probleem reduceren zonder het deliveryprotocol te wijzigen.

Maar zelfs als sterkere modellen vijfhonderd descriptors betrouwbaar verwerken, blijft de separation-of-concerns-bijdrage geldig. Permanente residentie van zelden gebruikte procedures blijft economisch en bestuurlijk onnodig. De protocolbijdrage is dus minder afhankelijk van de exacte grens dan de framing van het paper suggereert.

13.3 Kan promptkwaliteit het effect verklaren?

Ja. Beschrijvingen met overlappende terminologie, commerciële triggerpadding of onvoldoende negatieve criteria kunnen selection failure veroorzaken. Een alternatieve interventie is daarom:

descriptorlinting;
gecontroleerde ontologie;
unieke capabilitynamen;
expliciete inclusion- en exclusioncriteria;
learned routers;
deterministische prefilters.

Deze kunnen implicit triggering verbeteren zonder alle skills expliciet te refereren.

13.4 Kan retrieval het probleem beter oplossen?

Gedeeltelijk. Skill Retrieval Augmentation onderzoekt expliciet retrieval, incorporation en application als afzonderlijke fasen. SRA-Bench bevat 5.400 testinstanties, 636 handmatig geconstrueerde gold skills en een corpus van 26.262 skills. De auteurs vinden dat retrieval nuttig kan zijn, maar ook dat agents skills ongeveer even vaak laden wanneer een gold skill aanwezig is als wanneer externe hulp niet nodig is. Het knelpunt is dus niet uitsluitend vinden, maar ook besluiten wanneer en hoe een skill moet worden geladen en toegepast.

@skills vermijdt retrievalfouten wanneer het juiste pad al bekend is. Het verschuift dan echter het selectieprobleem naar:

de gebruiker;
de orchestrator;
een planner;
een registry search engine;
een upstream workflow.

Het protocol lost addressing op, niet discovery.

13.5 Kan meer compute het effect verklaren?

Een retrieval- of reflectionloop kan de juiste skill alsnog vinden, maar tegen hogere token-, latency- en toolkosten. Een verbetering die volledig door extra inference ontstaat, moet worden beoordeeld op cost per valid successful task, niet alleen op pass rate.

13.6 Kan betere tooling de skill overbodig maken?

Ja. Wanneer een procedure volledig kan worden gecodeerd als:

een typed API;
een policy;
een workflow definition;
een databaseconstraint;
een compilercheck;
een solver;
een schema validator;
een deterministic transformation;

dan behoort de kritieke logica daar te worden afgedwongen. Do not prompt what you can enforce.

Een skill is geschikt voor heuristiek, taakdecompositie, uitleg en contextafhankelijke procedurekeuze. Zij is ongeschikt als enige drager van toegangscontrole, integriteitscontrole of veiligheidsregels.

14. Vergelijking met de state of the art

14.1 Skills zijn aantoonbaar nuttig, maar niet uniform

SkillsBench is een belangrijker empirisch tegenwicht dan het @skills-paper zelf. De benchmark omvat 86 taken, waarvan 84 in de hoofdevaluatie, elf domeinen, zeven agent-modelconfiguraties en 7.308 trajectories. Curated skills verhogen de gemiddelde pass rate met 16,2 procentpunt. De effecten lopen echter uiteen van 4,5 procentpunt in software engineering tot 51,9 procentpunt in healthcare. Bij 16 van 84 taken verslechtert de prestatie. Self-generated skills leveren gemiddeld geen voordeel. Focused skills met twee tot drie modules presteren beter dan zeer uitgebreide documentatie.

Daaruit volgen drie belangrijke correcties op de @skills-narratief:

Het beschikbaar maken van meer skills is niet automatisch gunstig.
Skillkwaliteit en taakfit zijn belangrijker dan corpusomvang.
Een verkeerde of te complexe skill kan task success verlagen.

Het operationele doel moet dus niet zijn "maximise available skills", maar "maximise validated procedural fit" onder security-, cost- en governanceconstraints.

14.2 Paradigmavergelijking

Paradigma	Selectiemechanisme	Residentiekosten	Belangrijkste voordeel	Belangrijkste beperking
Installed progressive disclosure	Model matcht resident descriptions	Metadata permanent	Automatische activatie	Contexttax en probabilistische selectie
@skills explicit reference	Mens of orchestrator noemt pad	Geen voor niet-geïnstalleerde skills	Intentionaliteit en eenvoudige compositie	Juiste pad moet bekend zijn
Skill Retrieval Augmentation	Search/ranker plus modelselectie	Geen volledige catalogus	Discovery op schaal	Retrieval, incorporation en application kunnen afzonderlijk falen
Procedural memory	Agent leert of bewaart workflows	Variabel	Adaptatie op ervaring	Memory poisoning, drift en slechte zelfgeneratie
RAG	Retrieve declarative evidence	Geen permanente corpusresidentie	Actuele feitelijke informatie	Geen authority of betrouwbare procedure-uitvoering
MCP/tools	Gestructureerde toolinterface	Schemakosten afhankelijk van implementation	Typed execution interface	Zegt niet welke workflow of procedure juist is
Deterministische workflow	Formeel gedefinieerde stappen	Geen natuurlijke skillselectie nodig	Controleerbaarheid en herhaalbaarheid	Minder flexibel bij open taken
Solver of formele software	Geformaliseerd probleem	Taakspecifiek	Sterke correctness guarantees	Alleen toepasbaar op formaliseerbare delen

@skills en MCP zijn daarom complementair:

de skill beschrijft wat en waarom;
MCP of een tool-API bepaalt hoe een geautoriseerde handeling technisch wordt uitgevoerd;
policy bepaalt of de handeling mag worden uitgevoerd.

14.3 Wat is werkelijk nieuw?

Niet nieuw zijn:

Markdownprocedures;
filesystem packaging;
progressive disclosure;
Gittransport;
vendoring;
context references;
globpatronen;
caches;
lokale overrides.

De relevante vernieuwing is hun combinatie tot een minimale, agentneutrale delivery grammar met drie onafhankelijke lifecycle tiers. De bijdrage is dus voornamelijk architecturale synthese, niet een nieuw learning algorithm.

15. Architecturale implicaties voor enterprise AI

Het paper dwingt een nuttige herverdeling af over de AI-stack.

Laag	Gewenste rol
MODEL	Redeneren over de taak en procedure, geen rechten beheren
PROMPT	Identiteit, missie, constraints en minimale kritieke guidance
CONTEXT	Alleen taakrelevante, tijdelijke procedurekennis
MEMORY	Episodische, semantische en procedurele state gescheiden opslaan
RETRIEVAL	Kandidaten vinden en ranken, geen trust of authority verlenen
TOOLS	Typed, parametergevalideerde, least-privilege executors
ORCHESTRATION	Decompositie, routing, retries, termination en compensation
POLICY	Authorisation, risk tiers, approval en capability boundaries
EVALUATION	Task success, security, latency, cost en regressie meten
ASSURANCE	Onafhankelijke tests, provenance, contradiction checks en release gates

De centrale fout die vermeden moet worden is: skill selected, therefore skill authorised. De correcte relatie is: skill selected, therefore procedure may be considered. Een skill kan een capability aanvragen, maar niet verkrijgen.

Formeel:

AllowExecution(s,a) =
  ValidDigest(s)
  AND TrustedIssuer(s)
  AND NOT Revoked(s)
  AND Admitted(s)
  AND Capability(a) subset Authorised(workload, task)
  AND PolicyAllows(a)

Het pad levert hooguit de kandidaat s. Alle andere predicaten moeten buiten het model worden vastgesteld.

16. Verbetert @skills werkelijk agency?

Agency omvat ten minste:

planning;
decomposition;
tool use;
memory;
delegation;
reflection;
self-correction;
repair;
termination;
capability routing;
multi-agent coordination;
autonomy boundaries.

Het paper meet geen van deze dimensies rechtstreeks. @skills kan wel drie ondersteunende effecten hebben:

Betere procedurebeschikbaarheid: een agent kan relevante instructies op het juiste moment ontvangen.
Explicietere capability routing: een orchestrator kan een specifieke procedure aanwijzen in plaats van te hopen op impliciete triggering.
Lagere resident contextbelasting: meer context blijft beschikbaar voor actuele taakstate.

Maar dit is betere scaffolding, niet bewezen betere agency. Een agent die met @skills een planningprocedure leest, heeft niet automatisch een beter world model, correctere doelinterpretatie, veilige toolrechten, betrouwbare termination, succesvolle recovery of onafhankelijke outcome verification.

Ook multi-agent coordination wordt niet vanzelf veilig. Wanneer Agent A een skill of taak aan Agent B doorgeeft, moet B opnieuw verifiëren:

wie de delegatie gaf;
welke taakscope geldt;
welke skilldigest is toegelaten;
welke data mag worden gedeeld;
welke capabilities zijn verleend;
welke approval boundary geldt.

Trust mag niet transitief worden overgenomen uit prompttekst.

17. Securityanalyse: een skill is operationele inhoud

Een skill is niet slechts documentatie. Zij beïnvloedt welke handelingen een agent kiest, welke scripts worden uitgevoerd, welke tools worden aangeroepen en welke data worden gelezen of verstuurd.

Recente securitystudies bevestigen dat dit attack surface materieel is. Een onderzoek naar 98.380 skills uit twee registries identificeerde 157 skills met bevestigd kwaadaardig gedrag en 632 kwetsbaarheden over dertien aanvalstechnieken. De auteurs rapporteerden zowel credential theft via code execution als agentmanipulatie via adversarial instructions.

Een tweede studie onderzocht uitsluitend semantische manipulatie van SKILL.md. Korte tekstuele triggers bereikten tot 86 procent pairwise winst in discovery en 80 procent top-10-plaatsing. Functioneel equivalente kwaadaardige varianten werden gemiddeld in 77,6 procent van gepaarde selectietests gekozen. Governance-evasiontechnieken omzeilden een blocking verdict in 36,5 tot 100 procent van de onderzochte condities. Dat ondersteunt de conclusie dat skillmetadata operationele control-plane-input is, geen passieve documentatie.

MalSkillBench bevat 3.944 runtime-verified kwaadaardige skills plus 4.000 matched benign skills. De sterkste skill-specifieke detector behaalde volgens het onderzoek 98,4 procent recall op code injection, maar presteerde veel slechter op prompt injection en aanvallen op de agent control plane. Code scanners en prompt-injectiondetectors zien ieder slechts een deel van de hybride instructie-code-relatie.

De OWASP Agentic Skills Top 10 benoemt inmiddels expliciet malicious skills, supply-chain compromise, over-privileged skills, insecure metadata, untrusted external instructions, weak isolation, update drift, poor scanning, ontbrekende governance en cross-platform reuse. De huidige projectstatus moet als recente community guidance worden gelezen, niet als formele wettelijke norm.

17.1 Threat model voor @skills

Dreiging	Aanvalspad	Mogelijk gevolg	Vereiste deterministic control
Direct prompt injection	Gebruiker verwijst naar gemanipuleerde skill	Policy bypass, ongewenst gedrag	Skill als untrusted input behandelen
Indirect prompt injection	Skill verwijst naar externe of mutable instructies	Achteraf gewijzigde procedure neemt controle over	Geen runtime external instructions zonder pinning en admission
Tool-output injection	Script, website of API retourneert instructieachtige tekst	Agent verwart data met opdrachten	Typed tool outputs en content labeling
Context poisoning	Malicious descriptor of menu beïnvloedt selectie	Verkeerde skill of doelhijacking	Gescheiden discovery, trust en selection scores
Memory poisoning	Skill schrijft naar persistent memory	Langdurige gedragsverandering	Read-only skill mount, gated memory writes
Capability escalation	Skill zegt een krachtiger tool te gebruiken	Ongeautoriseerde actie	Externe PDP/PEP, skill verleent nooit rechten
Confused deputy	Skill gebruikt rechten van agent voor ander doel	Misbruik van legitieme credentials	Task-bound en audience-bound tokens
Unauthorised delegation	Skill delegeert naar onbekende agent	Data- of authority leakage	Signed delegation, re-authorisation per hop
Credential leakage	Instructies vragen secrets te lezen of loggen	Account compromise	Geen secrets in context, secret broker, egress policy
Data exfiltration	HTTP, Git, webhook of DNS wordt misbruikt	Verlies vertrouwelijke data	Egress allowlist, content inspection, quotas
SSRF	Resolver of script bereikt interne endpoints	Cloud metadata of interne service compromise	URL policy, DNS/IP validation, network isolation
Code execution	Skill bevat of downloadt scripts	Host compromise	Sandbox, allowlisted interpreters, read-only filesystem
Malicious dependency	Script gebruikt poisoned package	Supply-chain compromise	SBOM, lock, provenance en dependency admission
Provenance spoofing	Lookalike host, owner of naam	Vertrouwen in verkeerde artifact	Canonical issuer identity en signature verification
Update drift	Upstream content wijzigt na review	Reviewed artifact verschilt van runtime artifact	Alleen approved artifact, approved skilldigests en expliciete menselijke release
Local shadowing	Repository bevat lokale kopie onder vertrouwd remote pad	Onzichtbare vervanging	Resolution log, protected directories, CODEOWNERS
Evaluator manipulation	Skill levert eigen tests of passcriteria	False green	Onafhankelijke verifier buiten skill
Cross-agent trust abuse	Agent neemt upstream trustbesluit over	Cascading compromise	Per-agent policy evaluation en provenance preservation

17.2 Promptstructuur is geen security boundary

De meegeleverde SKILLS.md-instructie kan een agent met filesystem-, shell- en netwerktoegang als client laten functioneren. Het document instrueert de agent onder meer om bronnen zichtbaar te maken, bevestiging te vragen voor eerste of gewijzigde cloudscripts en skillinhoud geen veiligheidsregels te laten overschrijven. Dat zijn nuttige gedragsinstructies, maar zij zijn modelafhankelijk.

Een aanvaller richt zich juist op situaties waarin het model:

een instructie verkeerd classificeert;
een conflict niet herkent;
een bevestiging te laat vraagt;
een script als reeds vertrouwd beschouwt;
een tooloutput als hogere instructie interpreteert.

Daarom moet een runtime ook bij perfecte promptcompliance veilig blijven.

18. Zero Trust-referentiearchitectuur

NIST Zero Trust stelt dat geen impliciet vertrouwen mag worden verleend op basis van netwerklocatie of eigendom en dat authenticatie en authorisatie vóór toegang tot een resource moeten plaatsvinden. Voor distributed cloud-native omgevingen legt NIST bovendien nadruk op service identities, identity- en network-tier policies, policy enforcement en continue telemetry.

Voor agent skills betekent dit:

Een lokale skill is niet automatisch vertrouwd.
Een GitHubskill is niet automatisch onbetrouwbaar.
Een bekende naam is niet automatisch een bekende artifact.
Een toegelaten artifact is niet automatisch geautoriseerd voor iedere taak.

18.1 Gewenste control flow

def execute_with_skill(task, logical_ref, workload):
    resolved = resolver.resolve(logical_ref)
    artifact = artifact_store.fetch(resolved)
    verify_digest(artifact)
    verify_signature(artifact)
    assert_not_revoked(artifact)

    admission = policy_decision_point.evaluate_artifact(
        issuer=artifact.issuer,
        digest=artifact.digest,
        risk=artifact.risk_class,
        dependencies=artifact.sbom,
        requested_capabilities=artifact.capabilities,
    )
    if not admission.allow:
        raise SkillAdmissionDenied()

    mount = sandbox.mount_read_only(artifact)
    proposal = model.propose(
        task=task,
        procedure=mount.instructions,
        authority="none",
    )
    validate_schema(proposal)
    validate_parameters(proposal)

    action_decision = policy_decision_point.authorise_action(
        workload=workload.identity,
        task=task.id,
        action=proposal.action,
        resource=proposal.resource,
        requested_scope=proposal.scope,
    )
    if not action_decision.allow:
        raise ActionDenied()

    credential = token_broker.issue_short_lived_token(
        workload=workload.identity,
        audience=proposal.resource,
        scopes=action_decision.scopes,
    )
    result = tool_broker.execute(
        proposal=proposal,
        credential=credential,
        sandbox=mount,
    )
    deterministic_gate.verify(result)
    audit_log.append(
        skill_digest=artifact.digest,
        policy_decisions=[admission.id, action_decision.id],
        result_digest=hash(result),
    )
    return result

De fundamentele verdeling luidt: LLMs propose. Tools execute. Policies authorise.

18.2 Artifact admission

Een skill die het ecosysteem binnenkomt, moet vóór contextinjectie een admission pipeline doorlopen:

canonicalisation
→ exact host validation
→ immutable fetch
→ digest calculation
→ issuer verification
→ licence check
→ dependency inventory
→ static code scan
→ semantic instruction scan
→ capability extraction
→ network and filesystem intent analysis
→ risk classification
→ approval
→ signing
→ registry promotion

Een .source-bestand kan deel uitmaken van de provenance chain, maar is niet voldoende. Het paper vermeldt dat .source tijdens normale resolutie niet wordt geraadpleegd. Daarmee is het auditmetadata, geen enforcement control.

18.3 Runtime isolation

De skilldirectory moet read-only worden gemount. Schrijfbare scratchspace, projectbestanden, secrets en persistent memory moeten afzonderlijke resources zijn.

Minimale runtimecontrols:

aparte UID of workload identity;
read-only skill mount;
read-only projectmount tenzij write expliciet nodig is;
tijdelijke scratchdirectory;
CPU-, memory-, proces- en wall-clocklimieten;
standaard geen netwerk;
expliciete domain allowlist;
geblokkeerde cloud metadata endpoints;
geen toegang tot SSH-agent of host keychains;
seccomp/AppArmor/SELinux of equivalent;
output- en filesystem-diffregistratie;
vernietiging van sandbox na taak.

19. Identity en tool security

De paperarchitectuur zegt weinig over workload identity. Dat is verdedigbaar voor een minimalistisch deliveryprotocol, maar niet voor een systeem waarin skills tools kunnen aansturen.

19.1 Workload identity

Iedere agentinstantie en iedere gedelegeerde worker moet een afzonderlijke runtime identity hebben, bijvoorbeeld via OIDC workload federation. Die identiteit moet gekoppeld zijn aan:

node;
agenttype;
workloadversie;
task ID;
tenant of project;
assurance state;
toegestane capability class.

Een skill erft niet automatisch alle rechten van de hostagent.

19.2 OAuth2 en OIDC

Tokens voor tools en externe services moeten:

kortlevend zijn;
audience-restricted zijn;
minimale scopes bevatten;
task-bound zijn;
niet in prompts of skillbestanden voorkomen;
bij voorkeur sender-constrained zijn;
roteerbaar en intrekbaar zijn;
afzonderlijk voor read en write worden uitgegeven.

RFC 8707 ondersteunt expliciete resource indicators, zodat een token voor resource A niet als algemeen token voor resource B wordt uitgegeven. RFC 9449 maakt sender-constrained tokens via DPoP mogelijk en vermindert replayrisico bij gestolen bearer tokens. RFC 9700 geeft actuele OAuth2 security best practices.

De tool broker moet daarnaast controleren:

caller identity;
task identity;
skill digest;
requested operation;
target resource;
input parameters;
side-effect class;
approval state;
rate en quota.

19.3 Read en write scheiden

Een skill die informatie ophaalt, hoort niet automatisch te kunnen publiceren, wijzigen of verwijderen. Voorbeeld:

research.read != content.write != content.publish != policy.approve

Een writer kan content voorstellen. Een reviewer kan een oordeel voorstellen. Alleen een afzonderlijke publication authority mag een goedgekeurd artifact publiceren.

20. Assurance en het false-green-risico

Het @skills-paper behandelt skills primair als bruikbare procedurekennis. Maar skills kunnen ook beschrijven:

hoe succes wordt vastgesteld;
welke tests moeten worden uitgevoerd;
wanneer een fout genegeerd mag worden;
welke output als voldoende geldt.

Wanneer dezelfde skill of hetzelfde model generatie en evaluatie stuurt, ontstaat correlated failure. Een systeem kan dan rapporteren SUCCESS terwijl:

een requirement is gemist;
een test onvoldoende dekking heeft;
een ongeautoriseerde write is uitgevoerd;
een bron niet bestaat;
een vulnerability aanwezig blijft;
een publicatie onterecht is vrijgegeven.

Dat is false green.

20.1 Vereiste scheiding

GENERATION
    ↓
REVIEW
    ↓
TARGETED REPAIR
    ↓
INDEPENDENT ASSURANCE
    ↓
DETERMINISTIC GATE

Generation: de writer of uitvoerende agent produceert een kandidaat.
Review: een afzonderlijke reviewer controleert inhoud, evidence, contradictions en requirements. Een ander model of andere model-family vermindert correlatie, maar elimineert haar niet.
Targeted repair: alleen de aantoonbaar falende propositions of artifacts worden gewijzigd. Daarna wordt exact de gefaalde gate opnieuw uitgevoerd, plus regressietests.
Independent assurance: een afzonderlijke component controleert onder meer provenance, claim-evidence-relaties, policy compliance, security tests, data-classificationregels, tool traces, side effects, model- en skilldigest en unresolved contradictions.
Deterministic gate: de laatste gate is geen taalmodeloordeel, maar een policybeslissing op machineleesbare evidence.

20.2 Non-compensatory controls

Een hoge stijlscore mag een kritieke security failure niet compenseren. De volgende situaties moeten afzonderlijk blokkerend zijn:

invalid of ontbrekende signature;
ingetrokken skilldigest;
onbevoegde toolactie;
prompt injection die een policygrens passeert;
data-exfiltratie;
onbevoegde publication;
ontbrekende evidence voor een kernclaim;
mislukte privacy- of juridische gate;
kritieke test die niet slaagt.

CriticalFailure = 1  leidt tot  Release = 0

Dat is belangrijker dan een gewogen gemiddelde assurance score.

21. Governance, privacy en compliance

21.1 Technische mogelijkheid is niet hetzelfde als juridische of bestuurlijke toelaatbaarheid

Dimensie	Centrale vraag
Technische mogelijkheid	Kan de agent de skill laden en uitvoeren?
Operationele haalbaarheid	Is het betrouwbaar, onderhoudbaar en observeerbaar?
Juridische toelaatbaarheid	Mag de data voor dit doel, via deze partijen en locaties worden verwerkt?
Bestuurlijke wenselijkheid	Is het risico passend en is accountability expliciet belegd?

Een succesvolle resolver beantwoordt alleen de eerste vraag.

21.2 AVG

Skilltraces en agentlogs kunnen bevatten:

prompts;
persoonsgegevens uit bronmateriaal;
namen van gebruikers;
file paths;
toolparameters;
queryresultaten;
credentials of identifiers;
inhoud van conceptpublicaties;
beslissingen en reviewcommentaar.

Artikel 5 AVG vereist onder meer doelbinding en dataminimalisatie. De EDPB benadrukt daarnaast dat by default alleen gegevens mogen worden verwerkt die voor het specifieke doel noodzakelijk zijn, inclusief hoeveelheid, opslagduur en toegankelijkheid.

Voor de organisatie betekent dit:

geen volledige prompts loggen wanneer een redacted trace volstaat;
content en security telemetry gescheiden bewaren;
retentie per gegevenstype;
toegang tot traces op need-to-knowbasis;
persoonsgegevens niet naar publieke skillhubs sturen;
DPIA uitvoeren bij waarschijnlijk hoog privacyrisico;
skill discovery niet ongemerkt als behavioral telemetry gebruiken.

21.3 AI Act

De AI Act is sinds 2 augustus 2026 breed van toepassing, met uitzonderingen en uitgestelde termijnen voor bepaalde high-riskregels. De Europese Commissie en nationale autoriteiten zijn vanaf die datum gestart met handhaving. Artikel 50-transparantieverplichtingen gelden eveneens sinds 2 augustus 2026. Specifieke high-riskverplichtingen voor Annex III-gebruik zijn door de AI Omnibus verschoven naar 2 december 2027 en productgebonden AI naar 2 augustus 2028.

Voor de publicatieketen is vooral van belang:

AI-generated of altered content kan labeling vereisen;
provenance en machine-readable marking moeten ondersteund kunnen worden;
menselijke editorial control moet aantoonbaar en niet ceremonieel zijn;
publication authority moet buiten de writer-agent liggen;
evidence over model, prompt, skill en review moet reconstrueerbaar zijn.

21.4 Cbw, NIS2 en BIO2

De Nederlandse Cyberbeveiligingswet en Wet weerbaarheid kritieke entiteiten zijn op 15 augustus 2026 in werking getreden. De Cbw implementeert NIS2 en bevat onder meer registratie- en zorgplichten voor essentiële en belangrijke entiteiten. BIO2 versie 1.3 vormt sinds maart 2026 het overheidsbrede informatiebeveiligingskader en is nader afgestemd op de Cbw.

Een externe skillrepository moet daardoor als software- en informatiesupply chain worden behandeld. Relevante beheersmaatregelen zijn:

leveranciersbeoordeling;
artifact inventory;
vulnerability- en incidentmanagement;
secure change control;
continuïteit bij provideruitval;
revocation;
logging;
toegangsbeheer;
herstelprocedures;
aantoonbare managementverantwoordelijkheid.

Dit sluit tevens aan bij de risk-based ISMS-benadering van ISO/IEC 27001 en de lifecyclebenadering van NIST AI RMF en NIST SSDF.

22. Sovereignty: open source is geen soevereiniteit

Het protocol is open en de hub is optioneel. Dat zijn positieve eigenschappen. Maar soevereiniteit wordt niet bepaald door licentie alleen.

De feitelijke control points zijn:

Control point	Sovereignty-vraag
Naming	Wie bepaalt welk logisch pad naar welk artifact verwijst?
Registry	Wie kan publiceren, verwijderen, ranken of censureren?
Git hosting	In welke jurisdictie staan bron, metadata en access logs?
Signing roots	Wie bepaalt welke uitgevers vertrouwd zijn?
Identity provider	Wie kan workloads authenticeren of blokkeren?
Model/API	Waar worden context en prompts verwerkt?
Telemetry	Welke gebruiksdata verlaten de organisatie?
Update channel	Wie kan runtimecontent wijzigen?
Policy engine	Wie controleert authorisation?
Audit log	Wie bezit en kan de evidence wijzigen?
Revocation	Wie kan een compromised artifact uitschakelen?
Exit	Kunnen artifacts, metadata, histories en policies worden geëxporteerd?

Een gh:-pad behoudt een afhankelijkheid van GitHub voor beschikbaarheid, account governance, telemetry en juridische exposure. Lokale inference verwijdert die afhankelijkheid niet. Het model draait dan lokaal, maar procedurele content, discovery of updates kunnen nog steeds via buitenlandse control planes verlopen.

Een soevereine adaptation vereist daarom:

een eigen EU/Nederlandse mirror van toegelaten artifacts;
interne immutable digests;
interne signing en admission;
behoud van upstream provenance;
reproduceerbare export;
offline execution voor toegelaten skills;
een vervangbare resolveradapter;
eigen telemetry en revocation;
local inference waar data- of risicoclassificatie dat vereist.

De upstreambron blijft zichtbaar, maar is niet de runtime authority.

23. Economische analyse

23.1 De standing tax

Laat m het aantal agentbeurten zijn, f_i het aantal resident frontmattertokens van skill i, b_i de skill body, u_i het aantal daadwerkelijke loads, r_i de resolver-, netwerk- en cachekosten en a_i de admission- en assurancekosten.

Voor een installmodel met progressive disclosure:

C_installed = m * som(f_i) + som(u_i * b_i)

Voor just-in-time reference:

C_JIT = som(u_i * (b_i + r_i + a_i)) + C_registry + C_observability

Omdat bestaande progressive-disclosure-systemen de body al pas na triggering laden, is de primaire tokenbesparing:

delta_C = m * som(f_i) - som(u_i * (r_i + a_i))

Dit is een belangrijker en beperkter resultaat dan de suggestie dat de volledige skillbody permanent wordt bespaard.

De auteurs rapporteren in één working setup dat achttien geïnstalleerde skills ongeveer 1.500 tot 2.000 resident tokens per request veroorzaakten. In een sessie van twintig requests betekent dit bruto 30.000 tot 40.000 herhaalde inputtokens, vóór skill bodies. Prompt caching kan de factuur verlagen, maar verwijdert de descriptors niet uit de semantische context en lost instruction dilution dus niet noodzakelijk op.

23.2 Wanneer JIT waarschijnlijk gunstig is

JIT is waarschijnlijk aantrekkelijk wanneer:

veel skills beschikbaar zijn;
iedere skill zelden wordt gebruikt;
sessies veel beurten hebben;
het juiste pad betrouwbaar bekend is;
artifacts lokaal gecachet en vooraf toegelaten zijn;
de extra resolverlatency klein is;
skills voornamelijk read-only procedures bevatten.

23.3 Wanneer JIT kan verliezen

JIT kan duurder of trager zijn wanneer:

dezelfde skill vrijwel iedere beurt nodig is;
discovery meerdere retrieval- en reflectionrondes vereist;
remote sources bij ieder gebruik moeten worden geprobed;
iedere nieuwe digest een volledige admission pipeline activeert;
latency kritisch is;
netwerkconnectiviteit beperkt is;
offline uitvoering noodzakelijk is;
de procedure zeer groot is;
een deterministische tool hetzelfde werk goedkoper kan uitvoeren.

23.4 De juiste economische metric

Niet cost per token, maar:

CostPerValidSuccess =
  (C_model + C_retrieval + C_tools + C_assurance + C_recovery + C_operations)
  / P(valid, authorised and successful outcome)

Het paper levert onvoldoende latency-, GPU-, energie-, storage- en recoverydata om economische superioriteit vast te stellen.

24. Concreet effect op het ecosysteem

24.1 De drie protocoltiers

@skills-element	Besluit	Toelichting
Tier 1, mutable remote reference	EXPERIMENT	Alleen isolated, low-risk, read-only en zonder gevoelige data
Tier 2, project-local save	ADAPT	Beste basis voor gereviewde proceduremodules, maar immutable digest en admission toevoegen
Tier 3, autotrigger	MONITOR	Alleen enkele essentiële skills, geen brede directoryglobs
Geen manifest of security envelope	REJECT	Enterprise registrymetadata blijft noodzakelijk
Geen version pinning	REJECT voor privileged production	Gebruik immutable approved digests en gecontroleerde updatekanalen
Directory als menu	ADAPT	Geschikt voor discovery, niet voor automatische future-child-enrollment
Local-first shadowing	ADAPT	Alleen met expliciete overridepolicy, protected paths en resolved-digest logging
.source provenance	ADAPT	Uitbreiden met signature, issuer, SBOM, policy status en revocation
Eén instruction file als client	EXPERIMENT	Alleen in sandbox, nooit als security boundary
Explicit multi-skill reference	ADAPT	Als deterministic routing input, niet als bewijs van correcte toepassing

24.2 Control plane

Component	Besluit	Concrete wijziging
Control plane	ADAPT	Voeg een Skill Admission Controller, artifact proxy, PDP en revocation service toe
Registry	ADAPT	Maak registry content-addressed en bewaar digest, issuer, upstream, SBOM, permissions, risk tier, status en expiry
Router	ADAPT	Behandel een skillref als routing hint, resolveer naar approved digest en controleer task authority
Event bus	ADOPT	Voeg events toe voor discovered, resolved, verified, admitted, loaded, proposed, authorised, executed, failed en revoked
Federation Adapter	EXPERIMENT	Vertaal externe refs naar URN's en behoud provenance en policy context over nodegrenzen
Capability registry	ADOPT	Maak capabilities en toolrechten onafhankelijk van skillcontent
MCP/tools	ADAPT	Skills beschrijven procedures, MCP/tool broker levert typed execution en PEP-enforcement

Geen enkele agent mag rechtstreeks een mutable remote skill ophalen en daarna met hostrechten uitvoeren. Remote resolution moet via de control plane lopen.

24.3 Agents en infrastructuur

Component	Besluit	Concrete toepassing
Primaire agents	EXPERIMENT	Read-only JIT skillloading in shadow mode, zonder write- of publicationauthority
Secundaire agents	EXPERIMENT	Alleen isolated canary, gegeven de brede skill- en shell-attack surface
Workstation	EXPERIMENT	Development cache, scanning en reproductie, geen centrale trust root
Edge node	EXPERIMENT	Edgecache en execution node voor vooraf toegelaten artifacts
Lokale inference	EXPERIMENT	Benchmark contextkosten, skillcompliance en privacy zonder externe model-API
Server agents	ADAPT	Geen permanente secrets, alleen workload-bound short-lived tokens
Federated workers	ADAPT	Skilldigest, taskscope en authorisation decision bij iedere handoff opnieuw valideren

24.4 Workflow, evidence en publicatie

Component	Besluit	Concrete toepassing
Workflow-orchestratie	ADAPT	Gebruik skills als just-in-time proceduremodules binnen deterministische workflows
Evidence graph	ADAPT	Koppel iedere observatie aan skilldigest, model, tooltrace en bronprovenance
Claim ledger	ADOPT	Een skill mag claims voorstellen, maar nooit evidence- of approvalstatus wijzigen
Signal layer	EXPERIMENT	Skills mogen bronnen voorstellen en classificeren, zonder promotion authority
Evidence + Normalisation	ADAPT	Procedurele mappings via skill, structurele validatie via schema en code
Editorial Decision	ADOPT	Menselijke of formeel gedelegeerde beslissing blijft afzonderlijk
Writer	ADAPT	Laad stijlgidsen en inhoudelijke procedures JIT, pinned op approved digest
Reviewer	ADAPT	Gebruik onafhankelijk reviewmodel en deterministic claim-evidencechecks
Targeted repair	EXPERIMENT	Skillgestuurde reparatie alleen op gefaalde propositions, met regressiegate
Assurance gate	ADOPT	Maak integrity, security, evidence en publication authority non-compensatory
Publication pipeline	ADAPT	Publication authority blijft buiten de writer- en reviewer-agent

25. Consequenties voor de Agent Prompt Specification

@skills verandert niet alleen hoe prompts worden samengesteld. Het vereist een expliciete scheiding tussen procedurele guidance en runtime authority.

25.1 IDENTITY

De specificatie moet voor iedere geladen skill vastleggen:

skill_binding:
  logical_ref: "gh:publisher/repository/path"
  resolved_id: "urn:djimit:skill:publisher/name@sha256:..."
  digest: "sha256:..."
  issuer: "..."
  upstream_revision: "..."
  trust_tier: "L1"
  policy_channel: "approved"
  admission_decision_id: "..."

Een naam of pad zonder resolved digest is onvoldoende voor auditable execution.

25.2 MISSION

Een skill mag de missie verfijnen binnen de toegestane taak, maar niet verbreden. De task objective omvat de skill subprocedure. Nooit mag een skill instruction de task objective herdefiniëren.

25.3 AUTHORITY

De specificatie moet normatief bepalen:

een skill verleent geen capabilities;
een skill wijzigt geen scopes;
een skill creëert geen approval;
een skill kan geen publication authority verkrijgen;
een skill kan geen evidence-status promoveren;
een skill kan geen policy overschrijven.

25.4 TRUST MODEL

Iedere externe, nieuw gewijzigde of niet toegelaten skill heeft de status UNTRUSTED_PROCEDURAL_INPUT. Pas na admission ontstaat APPROVED_PROCEDURAL_ARTIFACT. Ook dan blijft de skill niet bevoegd om acties te autoriseren.

25.5 OPERATING PROCEDURE

De specificatie moet de verplichte runtimevolgorde opnemen:

resolve → verify → admit → load → propose → authorise → execute → validate → assure → record

Geen prompt mag deze volgorde verkorten.

25.6 EPISTEMIC POLICY

Een skill is een instructiebron, geen evidencebron. Een passage in een skill mag dus niet zelfstandig als bewijs dienen voor een externe claim. Het claim ledger moet onderscheiden:

PROCEDURAL INSTRUCTION;
FACTUAL SOURCE;
EMPIRICAL OBSERVATION;
POLICY RULE;
MODEL INFERENCE.

25.7 TOOL POLICY

Een skill kan voorstellen:

{
  "tool": "repository.read",
  "resource": "project-x",
  "operation": "list_files"
}

De control plane bepaalt of de tool bestaat, of de agent haar mag gebruiken, of de resource in scope is, welke parameters valide zijn, of extra approval nodig is en welk token wordt uitgegeven.

25.8 FAILURE POLICY

Fail-closed is vereist bij:

onbekende digest;
ongeldige signature;
revoked artifact;
ontbrekende provenance;
niet-toegelaten capability;
policy engine unavailable;
onverwachte netwerkbestemming;
poging tot authority promotion;
kritieke assurance failure.

Stale cache kan alleen worden gebruikt wanneer de risk tier en offline policy dat expliciet toestaan.

25.9 OUTPUT CONTRACT

Iedere output bevat ten minste:

artifact_status: proposed
skill_digests:
  - sha256:...
model_id: ...
evidence_refs: [...]
tool_actions: [...]
policy_decisions: [...]
side_effects: [...]
uncertainties: [...]
assurance_state: unverified

25.10 PUBLICATION AND AUTHORITY MODEL

De specificatie moet expliciet onderscheiden:

conversational output;
proposed artifact;
reviewed proposal;
approved artifact;
published artifact;
authoritative policy or specification.

Een writer, reviewer of skill mag een artifact niet zelf naar een hogere authority state promoveren. Formatting, zelfverzekerde formulering of een label in gegenereerde tekst heeft geen bestuurlijke werking. Alleen een externe, geautoriseerde state transition kan promotion uitvoeren.

25.11 Prompt guidance versus deterministic enforcement

Prompt guidance	Deterministic enforcement
Denk stap voor stap over de procedure	Toolrechten
Leg onzekerheid uit	OAuth scopes
Vraag om verduidelijking bij ambiguïteit	Audience restriction
Gebruik de skill alleen voor passende taken	Artifact admission
Noem gebruikte bronnen	Digest en signature verification
Meld mogelijke risico's	Sandbox en egress policy
Stop bij onvoldoende evidence	Evidence floor en release gate
Vraag menselijke approval	Approval state en PEP
Publiceer alleen na toestemming	Publication authority
Negeer kwaadaardige instructies	Context isolation en policy enforcement

De rechterkolom mag nooit uitsluitend in prompttekst bestaan.

26. Praktisch implementatiepad

PHASE 0, Discovery

Element	Invulling
Doel	Vaststellen welke procedurele kennis, resident prompts en toolrechten al bestaan
Component	Registry, Router, agents, workflow-orchestratie, writer en reviewer
Wijziging	Nog geen runtimewijziging
Test	Inventory van skills, prompts, tools, credentials, resident tokens, gebruiksfrequentie en owners
Gate	Volledige inventory voor canaryscope, goedgekeurd threat model en authority map
Evidence	Artifactlijst, dataflow, capabilitymatrix, promptbudget en risk register
Rollback	Niet van toepassing, read-only analyse

PHASE 1, Isolated reproduction

Element	Invulling
Doel	Protocol en referentie-implementatie onafhankelijk reproduceren
Component	Afgesloten CI-omgeving en lokale mirror
Wijziging	Pin repository op immutable commit, bouw package reproduceerbaar
Test	Parser, resolver, cache, save, autotrigger, path traversal, hostname spoofing, local shadowing, stale cache en collection limits
Gate	Reproduceerbare build, SBOM, alle correctness-tests groen, nul open critical/high findings
Evidence	Build hashes, testlogs, scanneroutput, dependencyrapport
Rollback	Vernietig omgeving en artifacts, geen productie-impact

PHASE 2, Benchmark

Element	Invulling
Doel	Vaststellen of JIT-skills kwaliteit of kosten verbeteren
Component	Testagents, lokale en API-modellen
Wijziging	Vier experimentele condities
Test	Installed, explicit JIT, retrieval JIT en deterministic workflow vergelijken
Gate	Vooraf geregistreerde non-inferiority- en costcriteria
Evidence	Ruwe trajectories, tooltraces, bootstrap-CI's, task verifiers
Rollback	Geen productiewijziging

Minimale experimentele factoren:

resident skill count: 0, 10, 25, 50, 100, 200;
conversation turns: 1, 5, 10, 20;
required skill chain: 1, 2, 4, 8;
instruction position: early, middle, late;
skill overlap: low, medium, high;
models: local and remote;
task classes: coding, research, editorial, data, security.

Primaire metrics:

trigger precision, recall en F1;
correct skill loading;
correct skill application;
deterministic task pass;
policy violations;
unauthorized side effects;
p50, p95 en p99 latency;
input- en outputtokens;
toolcalls;
recoveryloops;
cost per valid successful task.

Gebruik paired trials, voorafgaande poweranalyse, bootstrapconfidence intervals en voldoende herhalingen per stochastische conditie. Subjectieve beoordeling moet blind worden uitgevoerd en mag niet uitsluitend afhankelijk zijn van een model uit dezelfde family als de generator.

PHASE 3, Adversarial evaluation

Element	Invulling
Doel	Falsificeren van security- en assuranceclaims
Component	Resolver, Registry, tool broker, sandbox en assurance gate
Wijziging	Adversarial skillcorpus en aanvalsharness toevoegen
Test	Prompt injection, remote mutation, typosquatting, malicious scripts, SSRF, exfiltration, shadowing, stale revocation, directory drift, evaluator manipulation en delegation abuse
Gate	Nul critical escapes, alle unauthorized writes geblokkeerd, volledige traceability
Evidence	Attack traces, blocked decisions, sandboxlogs en forensic artifacts
Rollback	Alleen geïsoleerde omgeving, geen productie-impact

PHASE 4, Shadow mode

Element	Invulling
Doel	Utility meten zonder contextinjectie of side effects
Component	Router en Registry
Wijziging	Resolver suggereert skill en approved digest, maar agent gebruikt deze nog niet
Test	Vergelijk suggestie met huidige menselijke en agentkeuze
Gate	Acceptabele precision/recall, geen privacy- of securityincidenten
Evidence	Decision comparison en disagreement analysis
Rollback	Feature flag uitzetten

PHASE 5, Canary

Element	Invulling
Doel	Eén low-risk use case end-to-end uitvoeren
Component	Bij voorkeur writer of read-only evidence normalisation
Wijziging	Eén signed, immutable Tier 2-skill in production canary
Test	Task validity, provenance, latency, tool policy, rollback en revocation
Gate	Nul critical assurance failures, 100 procent verified provenance, geen onbevoegde side effects
Evidence	Complete execution traces en canaryrapport
Rollback	Route uitschakelen, digest quarantainen, vorige procedure herstellen

PHASE 6, Controlled integration

Element	Invulling
Doel	Uitbreiden naar writer, reviewer en normalisation
Component	Workflow-orchestratie, evidence graph, agents en assurance
Wijziging	PDP/PEP, signed registry channels en skill binding activeren
Test	End-to-end regressie, cross-agent handoff, failure recovery en publication block
Gate	Security-, privacy-, architectuur- en product owner approval
Evidence	Go-live dossier, policyset, testdekking, runbooks
Rollback	Registry channel terugzetten, specificatie-version rollback

PHASE 7, Operational observation

Element	Invulling
Doel	Drift, false green, costs en incidentgedrag observeren
Component	Event bus, Registry, telemetry en assurance
Wijziging	Dashboards, alerts en revocation drills
Test	Update drift, compromised issuer, node loss, cache loss, rollback en policy outage
Gate	Vooraf vastgesteld aantal afgeronde taken zonder critical failure en met stabiele SLO's
Evidence	Taskcohorten, incidentrecords, costdata, assurance regressions
Rollback	Terug naar vorige approved channel

PHASE 8, GO / HOLD / REJECT

Besluit	Voorwaarde
GO	Taskvaliditeit minimaal non-inferior, aantoonbare economic value, nul critical escapes, governance volledig
HOLD	Waarde aannemelijk maar één of meer beheersbare gates nog niet gehaald
REJECT	Trust, authority of assurance kan niet buiten prompttekst worden afgedwongen

Geen big-bang rollout en geen automatische promotie op basis van gemiddelde kwaliteitsscores.

27. Belangrijkste risico's en failure modes

Risico	Inherent risico	Failure mode	Primaire beheersing
Mutable upstream	Hoog	Gereviewde inhoud verandert vóór uitvoering	Immutable approved digest
Local shadowing	Hoog	Vertrouwd pad resolveert naar gemanipuleerde lokale kopie	Protected paths, CODEOWNERS, resolved-digest logging
Discovery poisoning	Hoog	Kwaadaardige skill wordt beter gerankt dan legitieme variant	Trust-aware retrieval en issuer verification
Prompt injection	Kritiek	Skill wijzigt agentdoel of omzeilt instructies	Untrusted-context treatment en external PEP
Capability escalation	Kritiek	Skill verkrijgt write-, shell- of publicationrechten	Capability registry en least privilege
Credential leakage	Kritiek	Skill leest of exfiltreert secrets	Secret broker, no secrets in prompt, egress policy
Stale cache	Hoog	Ingetrokken skill blijft offline uitvoerbaar	Signed revocation, TTL en risk-tiered offline policy
Future-child autotrigger	Hoog	Nieuwe upstream skill wordt zonder review resident	Geen directorywide autotrigger in productie
Malicious dependency	Kritiek	Script haalt compromised package binnen	SBOM, lockfile en dependency admission
Cross-agent trust loss	Hoog	Provenance of taskscope verdwijnt bij delegatie	Signed handoff envelope en re-authorisation
False green	Kritiek	Writer, reviewer en test delen dezelfde fout	Independent assurance en deterministic gate
Cost amplification	Middel tot hoog	Retrieval, repair en scanning maken JIT duurder	Cost per valid success en budget limits
Privacy leakage	Hoog	Prompts, paths of gebruikspatronen verlaten organisatie	Minimisation, private registry en telemetry policy
Revocation failure	Kritiek	Gecompromitteerde skill blijft in fleet actief	Central revocation en node acknowledgement
Governance bypass	Kritiek	Prompttekst promoveert output of authority	External state machine en publication control

28. Wat zou de centrale thesis overtuigend falsifiëren?

De waardepropositie van @skills moet worden herzien wanneer één of meer van de volgende observaties optreden:

Auto-triggering schaalt wel betrouwbaar: moderne agents behouden bij honderden resident descriptors stabiele trigger-F1 en task success, zonder relevante kosten of contextinterferentie.
Explicit references veroorzaken structurele discovery failure: gebruikers en orchestrators vinden het juiste pad zo zelden dat geïnstalleerde of retrieved skills significant betere valid task success leveren.
De contextbesparing is economisch irrelevant: prompt caching en verbeterde harness routing maken de standing tax verwaarloosbaar, terwijl resolver-, admission- en assurancekosten hoger zijn.
JIT remote content verhoogt incidentrisico substantieel: referenced skills veroorzaken, na controle voor capabilities en gebruiksfrequentie, meer policy violations of compromises dan reviewed installed copies.
Deterministische workflows domineren de relevante use cases: het merendeel van de waardevolle procedures kan goedkoper en betrouwbaarder als formele workflow of typed tool worden geïmplementeerd.
Procedurele content blijkt onvoldoende overdraagbaar: skills die in één model-harnesscombinatie werken, degraderen sterk bij andere modellen, agents of domeinen.
Skillcomposition verbetert geen eindresultaten: expliciet laden van meerdere correcte skills levert geen hogere task success op of introduceert juist meer conflicten.
Gebruik stimuleert auteurs niet: longitudinale catalogusdata laten geen hogere publicatie-, onderhouds- of kwaliteitsactiviteit zien na invoering van reference-based usage metrics.

Totdat deze tests zijn uitgevoerd, moet @skills worden behandeld als een sterke ontwerpstelling met gedeeltelijke empirische ondersteuning, niet als bewezen universele deliverytheorie.

29. Conclusie

@skills: Attention Is All You Have stelt een belangrijkere vraag dan de titel suggereert. Het probleem is niet alleen hoeveel skills een model kan onthouden. Het probleem is dat de huidige agentarchitectuur beschikbaarheid, ownership en automatische activatie via één installatieschakelaar bestuurt.

De paperbijdrage is overtuigend waar zij laat zien dat deze koppeling onnodig is. Een agent hoeft de meeste procedures niet permanent te kennen. Zij moeten vindbaar, adresseerbaar, controleerbaar en op het juiste moment beschikbaar zijn.

De evidence ondersteunt echter niet dat:

honderd een universele bovengrens is;
explicit referencing taakprestaties verhoogt;
composition end-to-end deterministisch wordt;
remote latest veiliger is dan pinning;
path-based provenance enterprise trust vervangt;
de aanpak production-ready is.

De belangrijkste systeemles luidt: path determinism ends where outcome determinism begins. Een expliciet pad kan bepalen welke bytes worden aangeboden. Het bepaalt niet of die bytes betrouwbaar zijn, of de uitgever vertrouwd is, of de procedure inhoudelijk correct is, of de agent haar juist interpreteert, of de agent de benodigde rechten heeft, of de tool veilig wordt uitgevoerd, of het resultaat valide is, of het artifact gepubliceerd mag worden.

Voor de organisatie is vooral Tier 2 waardevol: procedurekennis als Git-tracked, projectgebonden en expliciet geladen module. Maar de opgeslagen skill moet via de Registry worden vertaald naar een immutable, signed en policy-admitted artifact. De Router bepaalt relevantie, de capability registry bepaalt mogelijke acties, de PDP bepaalt authorisation, de tool broker voert uit, de assurance gate blokkeert false green en alleen een afzonderlijke authority promoveert naar publicatie.

Procedures horen niet permanent in de prompt. Privileges horen er nooit in.

Eindverdict

Dimensie	Oordeel	Onderbouwing
SCIENTIFIC CONTRIBUTION	MODERATE	Sterke architecturale synthese en relevante corpusmeting, maar geen gecontroleerde toets van de centrale capaciteits- en performanceclaims
ENGINEERING RELEVANCE	HIGH	De decompositie van content, persistence en triggering corrigeert een reëel platformprobleem
DJIMIT RELEVANCE	HIGH	Direct toepasbaar op Registry, Router, Federation, DAPS, workflow-orchestratie en de publicatieketen
PRODUCTION READINESS	LOW	Identity, pinning, signatures, permissions, sandboxing, revocation en assurance zijn onvoldoende uitgewerkt
EVIDENCE STRENGTH	MODERATE	Corpus- en implementatiebewijs zijn bruikbaar, maar de headline-thesis en systeemimpact zijn niet direct gemeten

Besluit: ADAPT

Niet ADOPT, omdat het protocolpad, de mutable updatefilosofie en promptgebaseerde veiligheidsinstructies onvoldoende zijn voor geprivilegieerde enterprise-uitvoering. Niet REJECT, omdat het just-in-time deliverymodel een principieel juiste correctie biedt op permanente promptresidentie en install-only lifecycle coupling.

ADAPT, door:

Tier 2 als standaard enterprisevorm te gebruiken;
remote references als untrusted input te behandelen;
logical path en immutable artifact identity te scheiden;
een eigen signed registry en admission pipeline te gebruiken;
capabilities en authorisation buiten skills te houden;
workload identity en short-lived tokens toe te passen;
read-only sandboxing en egress control af te dwingen;
onafhankelijke assurance en non-compensatory gates toe te voegen;
de Agent Prompt Specification uit te breiden met trust-, authority-, runtime- en publication semantics;
iedere productie-integratie via benchmark, adversarial evaluation, shadow mode en canary te valideren.

Bronnen

Li Yin, Zhi Li, Zhan Shi, Haoran Zhang, Haebin Seong, Zhangyang Wang. "@skills: Attention Is All You Have". arXiv:2608.12610, augustus 2026. https://arxiv.org/abs/2608.12610
SkillsBench: Benchmarking How Well Agent Skills Work Across Diverse Tasks. arXiv:2602.12670. https://arxiv.org/abs/2602.12670
Skill Retrieval Augmentation for Agentic AI (SRA-Bench). arXiv:2604.24594. https://arxiv.org/abs/2604.24594
MalSkillBench: A Runtime-Verified Benchmark of Malicious Agent Skills. arXiv:2606.07131. https://arxiv.org/abs/2606.07131
"Do Not Mention This to the User": Detecting and Understanding Malicious Agent Skills in the Wild. arXiv:2602.06547 (USENIX Security 2026). https://arxiv.org/abs/2602.06547
Under the Hood of SKILL.md: Semantic Supply-chain Attacks on AI Agent Skill Registry. arXiv:2605.11418. https://arxiv.org/abs/2605.11418
OWASP Agentic Skills Top 10. https://owasp.org
NIST Zero Trust Architecture (SP 800-207). https://csrc.nist.gov
RFC 8707 (Resource Indicators for OAuth 2.0), RFC 9449 (DPoP), RFC 9700 (OAuth 2.0 Security Best Current Practice). https://www.rfc-editor.org
EU AI Act, Verordening (EU) 2024/1689. https://eur-lex.europa.eu
Nederlandse Cyberbeveiligingswet en Wet weerbaarheid kritieke entiteiten (in werking 15 augustus 2026). https://www.rijksoverheid.nl
BIO2 versie 1.3 (maart 2026). https://www.digitaleoverheid.nl