Skip to content
← Tous les articles
· Delta1 Labs AI LicensingKeyright

Licencier les fonctionnalités d'IA et les agents autonomes

Keyright 2.9.0 ajoute des entitlements d'IA et d'agents de première classe : nommez les modèles, endpoints et outils qu'un client peut appeler, bornez un agent autonome avec un budget de crédits et un lease, et appliquez le tout fail-closed et hors ligne depuis une licence signée, avec un POST /v1/consume mesuré pour l'usage en cours. Voici la forme de l'entitlement, le JSON signé, les helpers du SDK en C#, Node, Python et Java, et un scénario concret de refus-du-modèle-non-licencié.

Une licence répondait autrefois à une seule question sur les fonctionnalités d’IA : ce client peut-il seulement les utiliser ? Cela ne suffit plus. Un produit d’IA aujourd’hui est un ensemble de capacités distinctes et tarifées séparément — quels modèles, quels fournisseurs, quels outils un agent peut appeler — et un agent autonome est un processus qui dépense de l’argent réel à chaque étape qu’il franchit. « Licencié : oui » ne dit rien sur la question de savoir si l’agent de ce client peut appeler gpt-5, atteindre un endpoint tiers, invoquer un outil shell, ou brûler dix mille crédits dans une boucle pendant la nuit.

Keyright 2.9.0 fait de tout cela ce qu’une licence accorde, en première classe. Les entitlements d’IA et d’agents nomment les modèles, endpoints et outils qu’un build peut toucher, et bornent un agent autonome avec un budget de crédits et un lease — le tout appliqué fail-closed et hors ligne depuis la licence signée, avec un POST /v1/consume mesuré et optionnel pour l’usage en cours sur les instances.

La forme de l’entitlement

Six clés conventionnelles reposent sur une tier de licence en tant que modèle ; émettre une licence sur cette tier les intègre dans le lease signé que le client active.

  • ai.enabled — l’interrupteur principal. Booléen. Lorsqu’il vaut false, rien d’autre ne compte.
  • ai.models — une liste d’autorisation d’identifiants de modèles que le build peut appeler, p. ex. openai/gpt-5, anthropic/claude-sonnet-4.6.
  • ai.endpoints — les hôtes d’API qu’un build peut atteindre, p. ex. api.openai.com.
  • ai.tools — les noms d’outils qu’un agent peut invoquer, p. ex. web.search, code.run.
  • agent.budget.credits — le plafond strict de crédits qu’un agent peut dépenser.
  • agent.lease.seconds — combien de temps un agent peut s’exécuter avant que son lease doive être renouvelé.

Les trois clés à valeur de liste sont des listes d’autorisation avec jokers. Un * correspond à un seul segment, donc openai/gpt-* admet openai/gpt-5 et openai/gpt-5-mini mais pas openai/o3 ; un * seul admet tout dans cette dimension. Les listes d’autorisation échouent en fermé : un modèle, endpoint ou outil qui ne correspond à rien dans la liste est refusé. Vous accordez en nommant ; vous n’avez jamais à énumérer ce qui est interdit.

Une licence signée, portant des entitlements d’IA

Voici à quoi ressemble une licence d’agent en tier Pro une fois émise. Le bloc ent est le modèle d’entitlements intégré au moment de l’émission ; tout le payload est signé, de sorte que chaque valeur ci-dessous est inviolable.

{
  "sub": "acme-corp",
  "product": "atlas-agent",
  "tier": "pro",
  "exp": "2027-11-12T00:00:00Z",
  "ent": {
    "ai.enabled": true,
    "ai.models": ["openai/gpt-5", "openai/gpt-5-mini", "anthropic/claude-*"],
    "ai.endpoints": ["api.openai.com", "api.anthropic.com"],
    "ai.tools": ["web.search", "code.run", "file.read"],
    "agent.budget.credits": 50000,
    "agent.lease.seconds": 3600
  },
  "sig": "ed25519:9f2c…c41a"
}

Notez ce qui est accordé : n’importe quel modèle Claude actuel (anthropic/claude-*) mais seulement deux modèles OpenAI précis ; deux endpoints de fournisseur ; trois outils ; cinquante mille crédits par agent ; un lease d’une heure. Changez un seul caractère — ajoutez un modèle, relevez le plafond — et la signature Ed25519 ne se vérifie plus face à la clé publique que l’application intègre au moment du build. La vérification échoue en fermé au lieu d’accorder silencieusement davantage.

Étape de l'agentappel modèle + outilLicence signéeai.models / ai.toolsvérifier hors ligne (fail-closed)autorisérefuséEnforceModel → throwcontinuerPOST/v1/consumebudget 50000− crédits→ restant

Lire et appliquer dans votre application

Le SDK analyse les entitlements du lease vérifié une fois, puis répond de façon synchrone sans appel réseau. En C#, les entitlements d’IA sont accrochés à info.Ai :

var client = KeyrightClient.Initialize(options);
var info = await client.ActivateAsync(licenseKey);   // lease mis en cache localement

// Vérifiez d'abord l'interrupteur principal.
if (!info.Ai.Enabled)
    throw new FeatureNotLicensedException("ai");

// Vérification souple — bifurque sans lever.
if (info.Ai.AllowsModel("openai/gpt-5"))
    useModel("openai/gpt-5");

// Vérification dure — lève ModelNotLicensedException lorsque le modèle n'est pas autorisé.
info.Ai.EnforceModel(requestedModel);

// Les endpoints et les outils fonctionnent de la même façon.
info.Ai.EnforceEndpoint("api.openai.com");
info.Ai.EnforceTool("code.run");

// Le plafond de budget par agent est lisible hors ligne.
long ceiling = info.AgentBudgetCredits;   // 50000, directement du lease signé

AllowsModel renvoie un booléen après avoir comparé l’identifiant à ai.models, jokers inclus ; EnforceModel est la forme qui lève, celle que vous placez à la frontière de l’appel lui-même. Les deux échouent en fermé : un modèle inconnu est refusé, et un lease sans clé ai.models n’accorde rien.

La même surface existe dans les autres SDK — mêmes identifiants, même sémantique de jokers, casse idiomatique :

// Node
if (info.ai.allowsModel("anthropic/claude-sonnet-4.6")) { /* ... */ }
info.ai.enforceModel(requestedModel);        // lève lorsque non autorisé
# Python
if info.ai.allows_model("anthropic/claude-sonnet-4.6"):
    ...
info.ai.enforce_model(requested_model)        # lève lorsque non autorisé
// Java
if (info.ai().allowsModel("anthropic/claude-sonnet-4.6")) { /* ... */ }
info.ai().enforceModel(requestedModel);       // lève lorsque non autorisé

Mesurer un budget de crédits par agent

agent.budget.credits est le plafond hors ligne — une limite stricte face à laquelle un agent isolé s’autolimite. Mais une véritable flotte d’agents partage un budget entre de nombreuses instances concurrentes, et chacune doit connaître le total en cours, pas seulement le plafond. C’est ce que mesure POST /v1/consume.

Avant (ou après) une unité de travail, l’agent déclare ce qu’il a dépensé. Le service décrémente un compteur partagé lié à la licence et renvoie le solde restant ; lorsqu’une charge ferait passer le solde sous zéro, elle est rejetée et l’agent s’arrête. L’appel est la seule partie de l’application d’IA qui touche le réseau, et uniquement lorsque vous optez pour la mesure partagée.

// Impute le budget partagé pour une étape. Échoue en fermé lorsqu'il est épuisé.
var result = await client.ConsumeAsync(new ConsumeRequest
{
    AgentId = agentId,
    Credits = step.EstimatedCredits
});

if (!result.Granted)
    throw new AgentBudgetExhaustedException(result.Remaining);  // Remaining == 0

logger.LogInformation("L'agent {Agent} a dépensé {Spent} ; il reste {Left} crédits",
    agentId, step.EstimatedCredits, result.Remaining);

Le plafond hors ligne et le compteur en ligne se composent. Un agent qui ne peut pas atteindre le service ne peut toujours pas dépasser info.AgentBudgetCredits localement ; un agent qui le peut ne peut en plus pas dépasser le solde partagé, de sorte que dix instances ne peuvent pas chacune dépenser le plafond complet. agent.lease.seconds borne l’autre axe : un agent emballé dont le lease a expiré s’arrête quel que soit le nombre de crédits restants.

Un scénario de gating concret

Assemblons tout. Un client disposant de la licence ci-dessus démarre un agent et, à l’étape trois, le planificateur demande openai/o3 — un modèle qui n’est pas dans sa liste d’autorisation — puis sollicite un lot de 40 000 crédits.

public async Task RunStep(AgentStep step)
{
    // 1. Refuse le modèle non licencié, avant tout appel au fournisseur ou toute dépense.
    if (!info.Ai.AllowsModel(step.Model))
        throw new ModelNotLicensedException(step.Model);   // "openai/o3" est refusé

    // 2. Applique l'outil et l'endpoint que l'étape veut.
    info.Ai.EnforceTool(step.Tool);
    info.Ai.EnforceEndpoint(step.Endpoint);

    // 3. Mesure la dépense face au budget partagé par agent.
    var charge = await client.ConsumeAsync(new ConsumeRequest
    {
        AgentId = step.AgentId,
        Credits = step.EstimatedCredits        // 40000 demandés
    });
    if (!charge.Granted)
        throw new AgentBudgetExhaustedException(charge.Remaining);

    await Execute(step);
}

openai/o3 est rejeté à la première ligne — hors ligne, avant d’acheter le moindre token — parce qu’il ne correspond à rien dans ai.models. Si le planificateur avait demandé openai/gpt-5-mini, la vérification du modèle passerait, celles de l’outil et de l’endpoint passeraient, et la charge de 40 000 crédits réussirait face à un plafond frais de 50 000 ; mais une seconde étape de ce type serait rejetée avec Remaining == 10000 < 40000, et l’agent s’arrêterait plutôt que de dépasser. Pas de changement de build, pas de redéploiement : déplacer openai/o3 dans le plan, ou relever le plafond à 100 000, est un changement du modèle de la tier et une licence réémise.

À retenir

Traitez les capacités d’IA comme vous traitez déjà les fonctionnalités : comme des entitlements nommés et signés que votre code vérifie localement. Laissez ai.models, ai.endpoints et ai.tools dire ce qu’un agent peut appeler et agent.budget.credits / agent.lease.seconds dire combien et pendant combien de temps — appliquez-les fail-closed avec AllowsModel / EnforceModel et mesurez la dépense partagée avec POST /v1/consume. La liste des modèles autorisés, la liste des outils autorisés et le plafond de budget tiennent tous hors ligne, directement depuis la signature ; la mesure est la seule chose pour laquelle vous touchez le réseau, et uniquement lorsqu’une flotte partage un budget. Votre packaging — quelle tier obtient quels modèles, combien de crédits — reste de la configuration sur le serveur, pas des constantes dans votre binaire.

Essayez Nebula.NET

Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.