nobulex-mcp-server
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.
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/sdkimport { 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 |
W3C DID-Erstellung mit Ed25519-Schlüsseln | |
Cedar-inspirierte DSL: Lexer, Parser, Compiler | |
SHA-256 hash-verkettetes, manipulationssicheres Protokoll mit Merkle-Beweisen | |
Pre-Execution-Durchsetzung – blockiert Verstöße, bevor sie ausgeführt werden | |
Deterministische Compliance-Verifizierung | |
Einheitliche API, die alle Primitive kombiniert | |
MCP-Compliance-Server für jeden MCP-kompatiblen Agenten | |
Befehlszeile: | |
LangChain-Middleware-Integration (PyPI) |
Integrationen
npm —
npm install @nobulex/sdkPyPI —
pip install langchain-nobulexMCP —
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.tsErstellt 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 failuresDokumentation
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
Links
Website: nobulex.com
npm: @nobulex
PyPI: langchain-nobulex
NIST: Docket NIST-2025-0035 (öffentlicher Kommentar eingereicht)
Lizenz
MIT – verwenden Sie es für alles.
Available Tools
4 toolscheck_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
Scored across 4 tools
Each tool has a clearly distinct purpose: checking actions, retrieving audit logs, setting rules, and verifying log integrity. No overlap or ambiguity.
All tool names follow a consistent verb_noun pattern in snake_case (check_action, get_audit_log, set_rules, verify_log).
Four tools is an appropriate scope for a compliance/auditing server; each tool serves a necessary function without redundancy.
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
Related MCP Connectors
Pre-execution governance for AI agents. Deterministic PASS/FAIL/REVIEW verdicts, replayable proof.
Policy-aware AI execution, verification, cost, and trajectory evidence for agents.
Check, limit, record and prove AI agent actions with 2-of-3 validators and onchain proofs.
Checks AI agent actions before they run. Signed, RFC 3161 timestamped evidence for audits.
Related MCP Servers
- AlicenseAqualityCmaintenanceProvides 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.41MIT
- AlicenseAqualityBmaintenanceCryptographic accountability for AI agents. Ed25519-signed receipts for every MCP tool call. Constraints, chains, AI judgment, invoicing, and local dashboard included.241MIT
- AlicenseNot gradedqualityDmaintenanceProvides tamper-proof audit logging for AI agents using SHA-256 hash chains, integrity verification, and compliance reporting for the EU AI Act.49 PyPI1MIT
- AlicenseNot gradedqualityCmaintenanceProvides permission gates and tamper-evident audit logging for AI agent tool executions, with declarative policies, consent ladders, and hash-chained verification.MIT