Skip to main content
Glama

Nobulex

El protocolo de prueba de comportamiento para agentes de IA autónomos.

Cada agente de IA hace promesas: "No transferiré más de $500", "Solo accederé a APIs aprobadas", "No tocaré datos de producción". Pero hoy en día, no hay forma de probar que un agente cumplió esas promesas. Los registros son escritos por el mismo software que está siendo auditado. El cumplimiento se afirma, nunca se prueba.

Nobulex cambia eso. Define reglas de comportamiento. Aplícalas antes de la ejecución. Prueba el cumplimiento con criptografía, no con confianza.

CI Tests License TypeScript

¿Qué es la Prueba de Comportamiento?

No puedes auditar una red neuronal. Pero sí puedes auditar acciones frente a compromisos establecidos.

verify(covenant, actionLog) → { compliant: boolean, violations: Violation[] }

Esto es siempre decidible, siempre determinista, siempre eficiente. Sin ML, sin heurísticas: prueba matemática.

Prueba de comportamiento significa que cada acción de un agente autónomo es:

  • Declarada — reglas de comportamiento definidas antes del despliegue en un lenguaje formal

  • Aplicada — violaciones bloqueadas en tiempo de ejecución, antes de la ejecución

  • Probada — cada acción encadenada mediante hash en un registro de auditoría a prueba de manipulaciones que terceros pueden verificar de forma independiente

Related MCP server: Agent Receipts

Inicio rápido

npm install @nobulex/sdk
import { createDID } from '@nobulex/identity';
import { parseSource } from '@nobulex/covenant-lang';
import { EnforcementMiddleware } from '@nobulex/middleware';
import { verify } from '@nobulex/verification';

// 1. Create an agent identity
const agent = await createDID();

// 2. Write behavioral rules
const spec = parseSource(`
  covenant SafeTrader {
    permit read;
    permit transfer (amount <= 500);
    forbid transfer (amount > 500);
    forbid delete;
  }
`);

// 3. Enforce at runtime
const mw = new EnforcementMiddleware({ agentDid: agent.did, spec });

// $300 transfer — allowed
await mw.execute(
  { action: 'transfer', params: { amount: 300 } },
  async () => ({ success: true }),
);

// $600 transfer — BLOCKED before execution
await mw.execute(
  { action: 'transfer', params: { amount: 600 } },
  async () => ({ success: true }),  // never runs
);

// 4. Prove compliance
const result = verify(spec, mw.getLog());
console.log(result.compliant);    // true
console.log(result.violations);   // []

Protocolo de verificación entre agentes

Antes de que dos agentes realicen una transacción, verifican la prueba de comportamiento del otro. Sin prueba, no hay transacción.

import { generateProof, verifyCounterparty } from '@nobulex/sdk';

// Agent A generates its proof-of-behavior
const proof = await generateProof({
  identity: agentA,
  covenant: spec,
  actionLog: middleware.getLog(),
});

// Agent B verifies Agent A before transacting
const result = await verifyCounterparty(proof);

if (!result.trusted) {
  console.log('Refusing transaction:', result.reason);
  return; // No proof, no transaction
}

// Safe to transact — Agent A is verified
await executeTransaction(proof.agentDid, amount);

El protocolo verifica seis cosas en orden: firma del pacto, firma de la prueba, integridad del registro, cumplimiento, historial mínimo y pacto requerido. Si alguna verificación falla, la transacción es rechazada.

Por qué es importante la Prueba de Comportamiento

Lo que existe hoy

Lo que falta

Guardrails filtran prompts y salidas

No hay prueba de que el agente siguió las reglas en la capa de acción

Monitoreo observa lo que hacen los agentes después del hecho

No hay aplicación antes de la ejecución

Identidad verifica quién es el agente

No hay verificación de lo que hizo el agente

Plataformas de gobernanza proporcionan paneles y políticas

No hay evidencia criptográfica que un tercero pueda verificar independientemente

La prueba de comportamiento llena el vacío: declarar → aplicar → probar.

El DSL de Pactos (Covenant DSL)

covenant SafeTrader {
  permit read;
  permit transfer (amount <= 500);
  forbid transfer (amount > 500);
  forbid delete;
  require counterparty.compliance_score >= 0.8;
}

Prohibir gana. Si algún forbid coincide, la acción se bloquea inmediatamente independientemente de los permisos. Denegación predeterminada para acciones no coincidentes. Las condiciones soportan >, <, >=, <=, ==, != en campos numéricos, de cadena y booleanos.

Tres palabras clave. Sin archivos de configuración. Sin YAML. Sin esquemas JSON. Solo reglas.

Arquitectura

┌─────────────────────────────────────────────────────────────┐
│                        Platform                             │
│              cli  ·  sdk  ·  mcp-server                     │
├─────────────────────────────────────────────────────────────┤
│                  Proof-of-Behavior Stack                    │
│                                                             │
│  ┌──────────┐  ┌──────────────┐  ┌────────────┐            │
│  │ identity │  │ covenant-lang│  │ action-log │            │
│  │  (DID)   │  │    (DSL)     │  │(hash-chain)│            │
│  └──────────┘  └──────────────┘  └────────────┘            │
│                                                             │
│  ┌────────────┐  ┌──────────────┐  ┌───────────────┐       │
│  │ middleware  │  │ verification │  │ composability │       │
│  │(pre-exec)  │  │ (post-hoc)   │  │(trust graph)  │       │
│  └────────────┘  └──────────────┘  └───────────────┘       │
├─────────────────────────────────────────────────────────────┤
│                      Foundation                             │
│            core-types  ·  crypto  ·  types                  │
└─────────────────────────────────────────────────────────────┘

Paquetes principales

Paquete

Qué hace

@nobulex/identity

Creación de W3C DID con claves Ed25519

@nobulex/covenant-lang

DSL inspirado en Cedar: analizador léxico, sintáctico y compilador

@nobulex/action-log

Registro a prueba de manipulaciones encadenado con hash SHA-256 con pruebas de Merkle

@nobulex/middleware

Aplicación previa a la ejecución: bloquea violaciones antes de que se ejecuten

@nobulex/verification

Verificación determinista del cumplimiento

@nobulex/sdk

API unificada que combina todas las primitivas

@nobulex/mcp-server

Servidor de cumplimiento MCP para cualquier agente compatible con MCP

@nobulex/cli

Línea de comandos: nobulex init, verify, inspect

@nobulex/langchain

Integración de middleware de LangChain (PyPI)

Integraciones

  • npm — npm install @nobulex/sdk

  • PyPI — pip install langchain-nobulex

  • MCP — npx @nobulex/mcp-server (funciona con Claude Desktop, Cursor, VS Code)

  • LangChain — middleware de cumplimiento de inserción directa

  • ElizaOS — plugin para acciones, evaluadores, proveedores

Comparación conceptual

Bitcoin

Ethereum

Nobulex

Qué verifica

Transferencias monetarias

Ejecución de contratos

Comportamiento del agente

Mecanismo

Prueba de trabajo

Prueba de participación

Prueba de comportamiento

Qué se prueba

Validez de la transacción

Transiciones de estado

Cumplimiento del comportamiento

Garantía

Dinero sin confianza

Contratos sin confianza

Agentes sin confianza

Demo en vivo

npx tsx demo/covenant-demo.ts

Crea dos agentes, define reglas de comportamiento, aplica en tiempo de ejecución, bloquea una transferencia prohibida y verifica criptográficamente el cumplimiento, todo en un solo script.

Desarrollo

git clone https://github.com/arian-gogani/nobulex.git
cd nobulex
npm install
npx vitest run    # 4,237 tests, 80 files, 0 failures

Documentación

Enlaces

Licencia

MIT: úsalo para lo que quieras.

Available Tools

4 tools
check_actionA

Check whether an action is allowed or blocked by the current covenant rules.

Inputs: action (required), params.

get_audit_logB

Returns the full hash-chained audit trail of all compliance checks.

Inputs: no named parameters.

set_rulesA

Set covenant rules using permit/forbid/require syntax. Each rule is a string like 'forbid delete_user' or 'permit read_data safe to read'.

Inputs: rules (required).

verify_logA

Independently verify the integrity of the hash-chained audit log. Detects any tampering.

Inputs: no named parameters.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.8/5.0

    Scored across 4 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose: checking actions, retrieving audit logs, setting rules, and verifying log integrity. No overlap or ambiguity.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern in snake_case (check_action, get_audit_log, set_rules, verify_log).

    Tool Count5/5

    Four tools is an appropriate scope for a compliance/auditing server; each tool serves a necessary function without redundancy.

    Completeness4/5

    Covers core operations: rule setting, action checking, audit log retrieval, and log integrity verification. Minor gap: no explicit rule deletion or modification beyond full replacement, but this is acceptable for the domain.

    Maintenance

    ActivityNo data
    ResponsivenessSyncing

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      C
      maintenance
      Provides covenant rule enforcement, hash-chained audit logs, and integrity verification for MCP-compatible agents. It enables users to define granular permission rules and maintain a tamper-evident audit trail of all actions.
      4
      1
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Provides permission gates and tamper-evident audit logging for AI agent tool executions, with declarative policies, consent ladders, and hash-chained verification.
      MIT