Skip to main content
Glama

Nobulex

Das Proof-of-Behavior-Protokoll für autonome KI-Agenten.

Jeder KI-Agent gibt Versprechen ab – „Ich werde nicht mehr als 500 $ überweisen“, „Ich werde nur auf genehmigte APIs zugreifen“, „Ich werde keine Produktionsdaten anfassen“. Aber heute gibt es keine Möglichkeit zu beweisen, dass ein Agent diese Versprechen eingehalten hat. Protokolle werden von derselben Software geschrieben, die geprüft wird. Compliance wird behauptet, aber nie bewiesen.

Nobulex ändert das. Definieren Sie Verhaltensregeln. Setzen Sie diese vor der Ausführung durch. Beweisen Sie Compliance mit Kryptografie, nicht mit Vertrauen.

CI Tests License TypeScript

Was ist Proof-of-Behavior?

Man kann ein neuronales Netzwerk nicht prüfen. Aber man kann Aktionen gegen erklärte Verpflichtungen prüfen.

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

Dies ist immer entscheidbar, immer deterministisch, immer effizient. Kein ML, keine Heuristiken – mathematischer Beweis.

Proof-of-Behavior bedeutet, dass jede Aktion eines autonomen Agenten:

  • Deklariert ist – Verhaltensregeln werden vor der Bereitstellung in einer formalen Sprache definiert

  • Durchgesetzt wird – Verstöße werden zur Laufzeit vor der Ausführung blockiert

  • Bewiesen ist – jede Aktion wird in einem manipulationssicheren Audit-Trail hash-verkettet, den Dritte unabhängig verifizieren können

Related MCP server: Agent Receipts

Schnellstart

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);   // []

Cross-Agent Verification Handshake

Bevor zwei Agenten Transaktionen durchführen, verifizieren sie gegenseitig ihr Proof-of-Behavior. Kein Beweis, keine Transaktion.

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);

Der Handshake prüft nacheinander sechs Dinge: Covenant-Signatur, Beweis-Signatur, Protokollintegrität, Compliance, Mindesthistorie und erforderliches Covenant. Wenn eine Prüfung fehlschlägt, wird die Transaktion verweigert.

Warum Proof-of-Behavior wichtig ist

Was heute existiert

Was fehlt

Guardrails filtern Prompts und Ausgaben

Kein Beweis, dass der Agent die Regeln auf Aktionsebene befolgt hat

Monitoring beobachtet, was Agenten im Nachhinein tun

Keine Durchsetzung vor der Ausführung

Identität verifiziert, wer der Agent ist

Keine Verifizierung, was der Agent getan hat

Governance-Plattformen bieten Dashboards und Richtlinien

Kein kryptografischer Nachweis, den Dritte unabhängig verifizieren können

Proof-of-Behavior schließt die Lücke: deklarieren → durchsetzen → beweisen.

Die Covenant DSL

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

Verbote haben Vorrang. Wenn ein forbid zutrifft, wird die Aktion sofort blockiert, unabhängig von Erlaubnissen. Standardmäßige Ablehnung für nicht übereinstimmende Aktionen. Bedingungen unterstützen >, <, >=, <=, ==, != für numerische, String- und boolesche Felder.

Drei Schlüsselwörter. Keine Konfigurationsdateien. Kein YAML. Keine JSON-Schemas. Nur Regeln.

Architektur

┌─────────────────────────────────────────────────────────────┐
│                        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                  │
└─────────────────────────────────────────────────────────────┘

Kernpakete

Paket

Was es tut

@nobulex/identity

W3C DID-Erstellung mit Ed25519-Schlüsseln

@nobulex/covenant-lang

Cedar-inspirierte DSL: Lexer, Parser, Compiler

@nobulex/action-log

SHA-256 hash-verkettetes, manipulationssicheres Protokoll mit Merkle-Beweisen

@nobulex/middleware

Pre-Execution-Durchsetzung – blockiert Verstöße, bevor sie ausgeführt werden

@nobulex/verification

Deterministische Compliance-Verifizierung

@nobulex/sdk

Einheitliche API, die alle Primitive kombiniert

@nobulex/mcp-server

MCP-Compliance-Server für jeden MCP-kompatiblen Agenten

@nobulex/cli

Befehlszeile: nobulex init, verify, inspect

@nobulex/langchain

LangChain-Middleware-Integration (PyPI)

Integrationen

  • npm — npm install @nobulex/sdk

  • PyPI — pip install langchain-nobulex

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

  • LangChain — Drop-in Compliance-Middleware

  • ElizaOS — Plugin für Aktionen, Evaluatoren, Provider

Konzeptueller Vergleich

Bitcoin

Ethereum

Nobulex

Was es verifiziert

Geldtransfers

Vertragsausführung

Agentenverhalten

Mechanismus

Proof of Work

Proof of Stake

Proof of Behavior

Was bewiesen wird

Transaktionsgültigkeit

Zustandsübergänge

Verhaltens-Compliance

Garantie

Vertrauensloses Geld

Vertrauenslose Verträge

Vertrauenslose Agenten

Live-Demo

npx tsx demo/covenant-demo.ts

Erstellt zwei Agenten, definiert Verhaltensregeln, setzt diese zur Laufzeit durch, blockiert eine verbotene Überweisung und verifiziert die Compliance kryptografisch – alles in einem Skript.

Entwicklung

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

Dokumentation

Lizenz

MIT – verwenden Sie es für alles.

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