Skip to content
← Todas las publicaciones
· Delta1 Labs AI LicensingKeyright

Licenciar funciones de IA y agentes autónomos

Keyright 2.9.0 añade entitlements de IA y de agentes de primera clase: nombre los modelos, endpoints y herramientas que un cliente puede invocar, limite un agente autónomo con un presupuesto de créditos y un lease, y aplíquelo todo fail-closed y offline desde una licencia firmada, con un POST /v1/consume medido para el uso en curso. Aquí está la forma del entitlement, el JSON firmado, los helpers del SDK en C#, Node, Python y Java, y un escenario concreto de denegar-el-modelo-no-licenciado.

Una licencia solía responder una única pregunta sobre las funciones de IA: ¿puede este cliente usarlas siquiera? Eso ya no basta. Un producto de IA hoy es un conjunto de capacidades distintas y tarificadas por separado —qué modelos, qué proveedores, qué herramientas puede invocar un agente— y un agente autónomo es un proceso que gasta dinero real en cada paso que da. “Licenciado: sí” no dice nada sobre si el agente de este cliente puede invocar gpt-5, alcanzar un endpoint de terceros, invocar una herramienta de shell o quemar diez mil créditos en un bucle durante la noche.

Keyright 2.9.0 convierte todo eso en lo que una licencia concede, de primera clase. Los entitlements de IA y de agentes nombran los modelos, endpoints y herramientas que una build puede tocar, y acotan a un agente autónomo con un presupuesto de créditos y un lease, todo aplicado fail-closed y offline desde la licencia firmada, con un POST /v1/consume medido y opcional para el uso en curso entre instancias.

La forma del entitlement

Seis claves convencionales viven sobre una tier de licencia como plantilla; emitir una licencia en esa tier las incrusta en el lease firmado que el cliente activa.

  • ai.enabled — el interruptor maestro. Booleano. Cuando es false, nada más importa.
  • ai.models — una lista de permitidos de identificadores de modelo que la build puede invocar, p. ej. openai/gpt-5, anthropic/claude-sonnet-4.6.
  • ai.endpoints — los hosts de API que una build puede alcanzar, p. ej. api.openai.com.
  • ai.tools — los nombres de herramientas que un agente puede invocar, p. ej. web.search, code.run.
  • agent.budget.credits — el techo fijo de créditos que un agente puede gastar.
  • agent.lease.seconds — cuánto tiempo puede ejecutarse un agente antes de que deba renovarse su lease.

Las tres claves con valores de lista son listas de permitidos con comodines. Un * coincide con cualquier segmento único, así que openai/gpt-* admite openai/gpt-5 y openai/gpt-5-mini pero no openai/o3; un * a secas admite todo en esa dimensión. Las listas de permitidos fallan en cerrado: un modelo, endpoint o herramienta que no coincide con nada de la lista queda denegado. Usted concede nombrando; nunca tiene que enumerar lo prohibido.

Una licencia firmada que lleva entitlements de IA

Así se ve una licencia de agente en tier Pro una vez emitida. El bloque ent es la plantilla de entitlements incrustada en el momento de la emisión; todo el payload está firmado, de modo que cada valor de abajo es a prueba de manipulaciones.

{
  "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"
}

Fíjese en lo que concede: cualquier modelo Claude actual (anthropic/claude-*) pero solo dos modelos OpenAI concretos; dos endpoints de proveedor; tres herramientas; cincuenta mil créditos por agente; un lease de una hora. Cambie un solo carácter —añada un modelo, suba el techo— y la firma Ed25519 ya no verifica contra la clave pública que la aplicación incrusta en tiempo de build. La comprobación falla en cerrado en lugar de conceder más en silencio.

Paso del agentellamada modelo + toolLicencia firmadaai.models / ai.toolsverificar offline (fail-closed)permitidodenegadoEnforceModel → throwcontinuarPOST/v1/consumepresupuesto 50000− créditos→ restante

Leer y aplicar en su aplicación

El SDK parsea los entitlements del lease verificado una vez y luego responde de forma síncrona sin llamada de red. En C#, los entitlements de IA cuelgan de info.Ai:

var client = KeyrightClient.Initialize(options);
var info = await client.ActivateAsync(licenseKey);   // lease cacheado localmente

// Compruebe primero el interruptor maestro.
if (!info.Ai.Enabled)
    throw new FeatureNotLicensedException("ai");

// Comprobación blanda — ramifica sin lanzar.
if (info.Ai.AllowsModel("openai/gpt-5"))
    useModel("openai/gpt-5");

// Comprobación dura — lanza ModelNotLicensedException cuando el modelo no está permitido.
info.Ai.EnforceModel(requestedModel);

// Endpoints y herramientas funcionan igual.
info.Ai.EnforceEndpoint("api.openai.com");
info.Ai.EnforceTool("code.run");

// El techo de presupuesto por agente se puede leer offline.
long ceiling = info.AgentBudgetCredits;   // 50000, directo del lease firmado

AllowsModel devuelve un booleano tras hacer coincidir el identificador con ai.models, comodines incluidos; EnforceModel es la forma que lanza, la que pone en la frontera de la propia llamada. Ambas fallan en cerrado: un modelo desconocido queda denegado, y un lease sin clave ai.models no concede nada.

La misma superficie existe en los demás SDK —mismos identificadores, misma semántica de comodines, convención de nombres idiomática:

// Node
if (info.ai.allowsModel("anthropic/claude-sonnet-4.6")) { /* ... */ }
info.ai.enforceModel(requestedModel);        // lanza cuando no está permitido
# Python
if info.ai.allows_model("anthropic/claude-sonnet-4.6"):
    ...
info.ai.enforce_model(requested_model)        # lanza cuando no está permitido
// Java
if (info.ai().allowsModel("anthropic/claude-sonnet-4.6")) { /* ... */ }
info.ai().enforceModel(requestedModel);       // lanza cuando no está permitido

Medir un presupuesto de créditos por agente

agent.budget.credits es el techo offline: un tope fijo contra el que un agente aislado se autolimita. Pero una flota real de agentes comparte un presupuesto entre muchas instancias concurrentes, y cada una necesita conocer el total en curso, no solo el tope. Eso es lo que mide POST /v1/consume.

Antes (o después) de una unidad de trabajo, el agente reporta lo que gastó. El servicio decrementa un contador compartido ligado a la licencia y devuelve el saldo restante; cuando un cargo dejaría el saldo por debajo de cero, se rechaza y el agente se detiene. La llamada es la única parte de la aplicación de IA que toca la red, y solo cuando usted opta por la medición compartida.

// Carga el presupuesto compartido por un paso. Falla en cerrado cuando se agota.
var result = await client.ConsumeAsync(new ConsumeRequest
{
    AgentId = agentId,
    Credits = step.EstimatedCredits
});

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

logger.LogInformation("El agente {Agent} gastó {Spent}; quedan {Left} créditos",
    agentId, step.EstimatedCredits, result.Remaining);

El techo offline y el medidor online se componen. Un agente que no puede alcanzar el servicio sigue sin poder exceder info.AgentBudgetCredits localmente; un agente que sí puede alcanzarlo tampoco puede exceder el saldo compartido, de modo que diez instancias no pueden gastar cada una el techo completo. agent.lease.seconds acota el otro eje: un agente desbocado cuyo lease ha caducado se detiene sin importar los créditos restantes.

Un escenario concreto de gating

Pongámoslo todo junto. Un cliente con la licencia de arriba arranca un agente y, en el paso tres, el planificador pide openai/o3 —un modelo que no está en su lista de permitidos— y a continuación solicita un lote de 40.000 créditos.

public async Task RunStep(AgentStep step)
{
    // 1. Deniega el modelo no licenciado, antes de cualquier llamada a proveedor o gasto.
    if (!info.Ai.AllowsModel(step.Model))
        throw new ModelNotLicensedException(step.Model);   // "openai/o3" queda denegado

    // 2. Aplica la herramienta y el endpoint que quiere el paso.
    info.Ai.EnforceTool(step.Tool);
    info.Ai.EnforceEndpoint(step.Endpoint);

    // 3. Mide el gasto contra el presupuesto compartido por agente.
    var charge = await client.ConsumeAsync(new ConsumeRequest
    {
        AgentId = step.AgentId,
        Credits = step.EstimatedCredits        // 40000 solicitados
    });
    if (!charge.Granted)
        throw new AgentBudgetExhaustedException(charge.Remaining);

    await Execute(step);
}

openai/o3 se rechaza en la primera línea —offline, antes de comprar un solo token— porque no coincide con nada en ai.models. Si el planificador hubiera pedido openai/gpt-5-mini, la comprobación del modelo pasaría, pasarían las de herramienta y endpoint, y el cargo de 40.000 créditos tendría éxito contra un techo fresco de 50.000; pero un segundo paso así se rechazaría con Remaining == 10000 < 40000, y el agente se detendría en vez de sobregastar. Sin cambio de build, sin redespliegue: mover openai/o3 al plan, o subir el techo a 100.000, es un cambio en la plantilla de la tier y una licencia reemitida.

Conclusión práctica

Trate las capacidades de IA como ya trata las funciones: como entitlements nombrados y firmados que su código comprueba localmente. Deje que ai.models, ai.endpoints y ai.tools digan qué puede invocar un agente y que agent.budget.credits / agent.lease.seconds digan cuánto y por cuánto tiempo —aplíquelos fail-closed con AllowsModel / EnforceModel y mida el gasto compartido con POST /v1/consume. La lista de modelos permitidos, la lista de herramientas permitidas y el techo de presupuesto se sostienen offline, directo de la firma; la medición es lo único para lo que toca la red, y solo cuando una flota comparte un presupuesto. Su packaging —qué tier obtiene qué modelos, cuántos créditos— sigue siendo configuración en el servidor, no constantes en su binario.

Prueba Nebula.NET

Endurece tu código .NET en minutos — empieza con la edición gratuita.