← Systèmes intelligents ambiants

Abilities : des données bornées, des tours figés

Partie III — Le paradigme · Chapitre 7 sur 9

La couche ambiante a répondu à où vivent les preuves. Ce chapitre est l’autre moitié d’un assistant qui agit : ce qu’il sait faire. La réponse de Mary est l’Ability.

Le système en un coup d’œil

Trois mots, trois tâches :

Une Ability est ce que Mary sait faire. Une Skill est une instruction lisible par machine à l’intérieur. Une Capability est le contrat — effet, permissions, limites — qui rend la Skill sûre à exécuter.

Ainsi writing est une Ability ; writing.type-at-cursor est une Skill qui s’y trouve ; text.write-at-surface est la Capability qu’elle requiert. (Un nom visible par le modèle comme type_at_cursor n’est que la Skill projetée dans le format de transmission d’un fournisseur — ce n’est pas la Skill elle-même.)

Et le lien avec le reste du système tient en une boucle. Une Ability est livrée comme un paquet .mary ; des validateurs l’admettent ou la refusent ; chaque tour fige un instantané de tout ce qui a été admis ; le modèle invoque une Skill depuis cet instantané ; le contrat de Capability est revérifié ; un adaptateur fait le travail ; un reçu consigne ce qui a changé.

Une collision de noms à signaler avant d’aller plus loin : l’écosystème d’Anthropic emploie « skill » pour autre chose — une Agent Skill est un dossier SKILL.md d’instructions markdown chargé dans le contexte d’un agent lorsqu’il est pertinent. La fin de ce chapitre compare directement les deux. D’ici là, « Skill » désigne celle de Mary.

Un dernier élément de vocabulaire : chaque Ability déclare un paradigme — discipline, applicationExpertise, systemControl ou reasoning. Dans les mots du schéma lui-même : « On peut être bon en design et expert de Sketch, tout en étant bon en design mais amateur dans Figma. » Le design est un savoir-faire portable ; Sketch est une expertise sur un seul outil. Cette scission porte ses fruits à la fin de ce chapitre.

Des données bornées, jamais de la prose

Un paquet .mary est du JSON canonique — clés triées, pour que les octets soient reproductibles — avec condensé d’intégrité et, en option, signature Ed25519. Dix sont livrés avec Mary aujourd’hui, parmi lesquels browsing, coding, scrivener, sketch, window-management et writing. La règle qui gouverne tout ce qu’ils contiennent est la phrase que je garderais si je ne pouvais en garder qu’une :

Tout ce qu’un paquet rédige est une donnée bornée. Des tokens, des énumérations fermées, des expressions typées, des limites en octets — jamais de la prose, jamais du code. Le moteur possède chaque phrase qu’il prononce ; un paquet ne fait que remplir des emplacements typés.

Voici une Skill de writing.mary (abrégée) :

JSON
{
  "id": "writing.type-at-cursor",
  "kind": "effectful",
  "access": "reversible",
  "execution": {
    "kind": "binding",
    "bindings": [{ "adapterID": "typer",
                   "operation": "type_at_cursor",
                   "targetClasses": ["editable-prose-surface"] }]
  },
  "modelExposure": {
    "enabled": true,
    "invocationName": "type_at_cursor",
    "parameters": [{ "name": "text", "type": "string", "required": true }]
  },
  "requirements": {
    "capabilities": ["text.write-at-surface"],
    "optionalInteractions": ["interaction.text-selection"],
    "supportingAbilities": ["window-management"]
  },
  "routing": { "conflictPolicy": "preferDirectInteraction" }
}

Tout ce qui porte la charge est un champ typé : classe d’effet, Capability requise, interactions consommables, Abilities de soutien, politique d’acheminement, et opération d’adaptateur qui fait le travail. Les chaînes descriptives sont des métadonnées d’interface — elles ne deviennent jamais autorité de prompt système, quel que soit le signataire du paquet.

Et l’admission est réelle : un paquet n’est que des octets tant que les validateurs ne l’ont pas accepté — identité, skills, références de schéma, honnêteté du paradigme, plus une passe de graphe sur tout ce qui est installé (un propriétaire par identifiant de schéma, pas de noms d’invocation en collision, pas de cycles de dépendance). Un paquet qui déclare une capacité destructrice sans exigence de confirmation est refusé avant même de rencontrer un tour.

Le tour figé

Déclarer la capacité n’est que la moitié du mécanisme. L’autre moitié est de savoir quand la capacité peut changer.

À l’entrée du tour, Mary fige un unique AbilityRuntimeSnapshot immuable — tout le registre, sous forme de révision adressée par UUID — et le tour entier s’exécute contre lui : un tour ne peut jamais commencer sous une révision de schéma et dispatcher sous une autre. Modifiez un paquet dans l’Ability Studio en plein tour et le nouveau registre s’active pour le tour suivant ; le tour en cours garde son monde.¹

Le dispatch revérifie tout. Un appel de forme « outil » d’un fournisseur (ce mot est mis en quarantaine dans les adaptateurs de fournisseur) est immédiatement retraduit en invocation de Skill, puis le contrat figé et la sécurité locale sont revalidés avant que quoi que ce soit s’exécute. Les contraintes de Capability sont un plancher dur que Mary détient — limites de charge utile, durée, confirmation, mise en attente, listes d’autorisation de cibles — et aucune préférence de paquet ne peut les contourner.

Et une exigence non satisfaite n’est pas une erreur. Les Skills à effet n’existent pour un tour que tant qu’un adaptateur compatible est installé et prêt ; retirez l’adaptateur et elles disparaissent de la liste du tour suivant, installez-le et elles réapparaissent. Dormantes, pas cassées. Gardez cette idée en tête pour le chapitre 8.

Enseigner sans code

Les paquets livrés incluent scrivener.mary : une intégration complète avec une application de manuscrit tierce — manipulation du classeur, scission de l’éditeur, lecture du corpus de documents — exprimée entièrement sous forme de données déclaratives. Dans les mots de la spécification, « il n’y a aucun fichier source Scrivener dans l’arborescence ».

Un plugin dynamique déclare l’application qu’il pilote et, pour chaque opération, une recette construite à partir d’un vocabulaire fini d’étapes — des expressions typées sur des littéraux, des entrées déclarées et une géométrie observée. Un moteur compilé unique, détenu par Mary — Remote Hands, qui travaille à travers l’interface visible de macOS — interprète chaque recette. Le paquet porte de la connaissance, jamais un interpréteur : enseigner une nouvelle application demande un fichier .mary ; ajouter une nouvelle faculté d’entrée demande une version de Mary.

Comme Remote Hands opère la même interface que la personne, ses règles passent d’abord par l’humain — il épingle le processus, prend un instantané du monde de l’utilisateur et annule dès qu’une entrée physique arrive :

La personne gagne toujours. Après qu’une entrée physique a annulé une exécution, Mary ne reprend pas le focus et ne ramène pas le curseur sous elle. C’est de l’automatisation visible.

Où SKILL.md s’arrête

Le mérite d’abord : la divulgation progressive des Agent Skills est une bonne conception — noms et descriptions préchargés à peu de frais, corps chargé quand il est pertinent, fichiers lus à la demande. Comme moyen de donner à un agent un matériau de référence approfondi, cela fonctionne.

Mais un SKILL.md est, structurellement, de la prose injectée dans le contexte d’un seul agent, et chaque conséquence de cette forme tombe sur un mécanisme que ce chapitre a déjà décrit. Six paires, d’après la documentation publique et mon propre usage à l’heure où j’écris — l’écosystème évolue vite, certaines de ces remarques ont donc pu changer :

Le chargement est à sens unique. Une fois que le corps d’une skill entre dans la conversation, seule une compaction avec perte l’en évince. Une Ability n’est jamais « dans » une conversation — retirée veut dire absente de l’instantané suivant. Le déchargement est le cycle de vie ordinaire, pas du ramasse-miettes.

Les dépendances ne peuvent pas être déclarées. Une skill ne peut pas dire « j’ai besoin du calendrier », s’activer quand il apparaît ou se désactiver quand il part — la composition, c’est le modèle qui se trouve avoir lu les deux. Le bloc requirements d’une Skill de Mary est typé et résolu par le runtime à chaque tour contre ce qui est réellement installé et prêt.

Les instructions sont consultatives. Une skill influence le modèle, et le modèle peut porter son attention ailleurs ; la propre recommandation de l’écosystème pour un comportement qui doit absolument avoir lieu est un autre mécanisme (les hooks). Un paquet .mary ne demande pas poliment : les validateurs le refusent à l’admission, et les contraintes de Capability tiennent au dispatch.

La découverte a un budget. La liste des skills est plafonnée, et les descriptions les moins utilisées tombent en premier — de sorte que la skill rare et de grande valeur est précisément celle qui devient invisible. La liste de Mary n’est pas de la prose en concurrence pour l’attention : des prédicats d’acheminement et un arbitrage par tour décident, et la rareté ne coûte rien.

La pré-approbation n’est pas une restriction. Les autorisations d’outils d’une skill pré-approuvent ; chaque outil reste appelable. Un contrat de Capability confine — classe d’effet, permissions, limites, confirmation — et Mary le détient, de sorte qu’un paquet ne peut pas se voter du pouvoir.

La portabilité est étroite. Les skills personnelles vivent sur une seule machine et se dégradent hors de leur chemin d’origine. Un paquet .mary est fait d’octets canoniques : la CI reconstruit sketch.mary à partir de son propre pas-à-pas documenté et affirme l’égalité octet pour octet avec le fichier livré. La portabilité est un test, pas une affirmation.

Rien de tout cela n’est une accusation — les Agent Skills résolvent un problème différent, plus étroit : augmenter le contexte d’un agent, à la demande, avec du texte. L’affirmation que je fais, elle, est que « ce que l’assistant sait faire » mérite le même sérieux architectural que « ce dont l’assistant se souvient », et que de la prose dans une fenêtre de contexte n’est pas une architecture. C’est un indice.

Le cadrage qui sous-tend cette affirmation — un modèle comme machine à états dont le seul alphabet est le langage, et ce qui en découle pour tout ce avec quoi on tente de le configurer — est un essai à part entière : Linguistic State Machines. Ce chapitre est le mécanisme ; celui-là est la dérivation.

Le bénéfice : un profil indexé par savoir-faire

Structurer la capacité ainsi offre une récompense discrète. Mary accumule un profil comportemental de la manière dont vous travaillez — des principes de style, extraits de vos vrais documents — et l’indexe par Ability, pas par application. Votre voix en prose, apprise dans Pages, est un fait sur votre écriture — elle est donc là quand vous écrivez dans Scrivener, qui n’existait pas dans le système quand le principe a été appris. C’est la scission discipline / applicationExpertise du début de ce chapitre qui se concrétise.

Et les principes sont gouvernés comme des preuves, pas comme un cache : l’ampleur avant la croyance, l’hystérésis avant la rétrogradation, et une décroissance sur plusieurs semaines jusqu’à un plancher — une courbe, pas une falaise, parce qu’« une personne ne cesse pas d’écrire d’une certaine manière un mardi ; elle dérive, et une falaise ne peut pas voir une dérive ».

Une capacité comme donnée bornée, validée, par tour ; une personnalisation indexée par savoir-faire ; les deux portables. Voilà l’amélioration.

Une capacité que vous ne pouvez pas décharger n’est pas installée — elle est mémorisée.