Nobulex

The trust layer for the autonomous economy.

AI agents are shipping into production. Nobody can prove what they actually do. Nobulex fixes that with cryptographic receipts: signed proof before and after every agent action, hash-chained, verifiable by anyone.

Status

• Bilateral receipt primitive merged into Microsoft Agent Governance Toolkit (PRs #1302, #1333)
• 10/10 byte-match verified against APS bilateral-delegation fixtures (reproduce it yourself)
• Five independent implementations validated (AgentGraph, APS, AgentID, HiveTrust, Nobulex) across TypeScript and Python
• Named as fourth-party verifier in cross-implementation composition fixture
• OpenSSF Best Practices passing badge
• Strategic vision in docs/OBSERVATORY-VISION.md; first issue of the Agent Reliability Index in observatory/issue-001-charter.md; methodology in docs/AGENT-RELIABILITY-INDEX.md

$ npx tsx examples/demo.ts

Agent A declares covenant: permit read, forbid transfer > 500
Agent A executes 5 actions...
  ✓ read /data/users — allowed
  ✓ transfer $300 — allowed
  ✓ read /data/orders — allowed
  ✗ transfer $600 — BLOCKED by covenant
  ✓ read /data/config — allowed

Agent B verifies Agent A...
  ✓ Step 1: Covenant signature valid
  ✓ Step 2: Proof signature valid
  ✓ Step 3: Log integrity verified (5 entries, chain intact)
  ✓ Step 4: Compliance check passed (0 violations)
  ✓ Step 5: History length sufficient (5 ≥ 1)
  ✓ Step 6: Covenant matches requirements
  ✓ Step 7: Audience binding confirmed
  ✓ Step 8: Task class verified

Result: Agent B trusts Agent A ✅

Agent C presents tampered proof...
  ✓ Step 1: Covenant signature valid
  ✓ Step 2: Proof signature valid
  ✗ Step 3: FAILED — hash chain broken at entry 2

Result: Agent B refuses Agent C ❌

Three primitives. That's the whole protocol:

1. Declare — write rules: permit, forbid, require
2. Enforce — check every action before it runs
3. Prove — tamper-evident hash chain anyone can verify

Try it live · Policy Designer · Quickstart · Compare · Receipt Schema · Pricing · IETF Draft

What is Proof-of-Behavior?

You can't audit a neural network. But you can audit actions against stated commitments.

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

This is always decidable, always deterministic, always efficient. No ML, no heuristics — mathematical proof.

Proof-of-behavior means every autonomous agent action is:

• Declared — behavioral rules defined before deployment in a formal language
• Enforced — violations blocked at runtime, before execution
• Proven — every action hash-chained into a tamper-evident audit trail that third parties can independently verify

Quick Start

npm install @nobulex/sdk

import { createDID, parseSource, EnforcementMiddleware, verify } from '@nobulex/core';

// 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

Before two agents transact, they verify each other's proof-of-behavior. No proof, no transaction.

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

The handshake checks eight things in order: covenant signature, proof signature, log integrity, compliance, minimum history, required covenant, audience binding, and task class scoping. If any check fails, the transaction is refused.

Why Proof-of-Behavior Matters

Proof-of-behavior fills the gap: declare → enforce → prove.

Conceptual Comparison

Live Demo

npx tsx examples/demo.ts

Creates two agents, defines behavioral rules, enforces at runtime, blocks a forbidden transfer, generates a proof-of-behavior, runs the 8-step handshake, and then shows the same handshake rejecting a third agent whose log was tampered with.

npx tsx examples/langchain-agent.ts   # covenant enforcement around a mocked LangChain agent
npx tsx benchmarks/bench.ts           # protocol performance on your hardware

Security Audit

We've conducted an internal security review. Here's what we tested and what we found:

Verified secure:

• Hash chain integrity: modifying any entry breaks the chain (property-tested with fast-check across random chains of varying length).
• Signature forgery: invalid signatures are rejected 100% of the time.
• Replay attack prevention: audience-bound proofs fail when replayed to a different verifier (property-tested).
• Covenant enforcement: forbidden actions are blocked before execution, never after.

Known limitations:

• No key revocation mechanism yet.
• No rate limiting on handshake verification.
• Single-threaded chain verification.
• Clock skew tolerance is 0.

See docs/threat-model.md for the full threat model.

Development

git clone https://github.com/arian-gogani/nobulex.git
cd nobulex
npm install
npx vitest run             # full test suite (incl. fast-check property tests)
npx tsx examples/demo.ts   # see the protocol run end-to-end
npx tsx benchmarks/bench.ts

Standards

• IETF Internet-Draft — draft-gogani-nobulex-proof-of-behavior-00: Proof-of-Behavior Protocol for Autonomous AI Agents
• LangChain RFC #35691 — ComplianceCallbackHandler, 10+ implementations converging
• NIST RFI Response — Formal comments to NIST AI Agent Standards Initiative
• Microsoft AGT — Bilateral receipt primitive merged (PRs #1302, #1333)

Ecosystem

Projects building on or composing with Nobulex:

Documentation

• API Reference — Full API docs generated with TypeDoc (npm run docs:api)
• Proof-of-Behavior Spec — Formal standard specification (CC-BY-4.0)
• White Paper — Formal protocol specification
• Receipt Schema — Every field, verification steps, examples
• Getting Started — Developer guide

Links

• Website: nobulex.com
• Try it: nobulex.com/try
• npm: @nobulex
• IETF: draft-gogani-nobulex-proof-of-behavior-00

License

MIT