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.

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

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

Proof-of-Behavior Spec — Formale Standardspezifikation (CC-BY-4.0)
White Paper — Formale Protokollspezifikation
Getting Started — Entwicklerhandbuch
NIST RFI Response — Formelle Kommentare zur NIST AI Agent Standards Initiative

Lizenz

MIT – verwenden Sie es für alles.

nobulex-mcp-server