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.

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

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

Especificación de Prueba de Comportamiento — Especificación estándar formal (CC-BY-4.0)
Libro blanco — Especificación formal del protocolo
Primeros pasos — Guía para desarrolladores
Respuesta a RFI del NIST — Comentarios formales a la Iniciativa de Estándares de Agentes de IA del NIST

Enlaces

Sitio web: nobulex.com
npm: @nobulex
PyPI: langchain-nobulex
NIST: Expediente NIST-2025-0035 (comentario público enviado)

Licencia

MIT: úsalo para lo que quieras.

nobulex-mcp-server