TIBET Core

The Linux of AI Provenance

A minimal, embeddable provenance engine for any device. From microcontrollers to cloud servers.

What is TIBET?

Transaction/Interaction-Based Evidence Trail

TIBET captures the four dimensions of every AI action:

Dimension	Dutch	Meaning
ERIN	"Er in"	What's IN the action (content)
ERAAN	"Er aan"	What's attached (dependencies)
EROMHEEN	"Er omheen"	Context around it (environment)
ERACHTER	"Er achter"	Intent behind it (why)

Installation

Python

pip install tibet-core

JavaScript/Node.js

npm install tibet-core

Rust

[dependencies]
tibet-core = "0.1"

Quick Start

Python

from tibet_core import TibetEngine

engine = TibetEngine()

# Create a provenance token
token = engine.create_token(
    token_type="action",
    erin="User requested translation",
    eraan=["model_v1", "tokenizer_v2"],
    eromheen='{"env": "production"}',
    erachter="Fulfilling user request",
    actor="agent_001"
)

print(f"Token ID: {token.id}")
print(f"Valid: {token.verify()}")
print(f"JSON: {token.to_json()}")

JavaScript

import { TibetEngine } from 'tibet-core';

const engine = new TibetEngine();

const tokenJson = engine.create_token(
    "action",
    "User requested translation",
    JSON.stringify(["model_v1", "tokenizer_v2"]),
    '{"env": "production"}',
    "Fulfilling user request",
    "agent_001",
    null  // no parent
);

const token = JSON.parse(tokenJson);
console.log(`Token ID: ${token.id}`);
console.log(`Valid: ${engine.verify(tokenJson)}`);

Rust

use tibet_core::TibetEngine;

let engine = TibetEngine::new();

let token = engine.create_token(
    "action",
    "User requested translation",
    &["model_v1", "tokenizer_v2"],
    r#"{"env": "production"}"#,
    "Fulfilling user request",
    "agent_001",
    None,
);

assert!(token.verify());

Chaining Tokens

Create audit trails by linking tokens:

# Parent action
request = engine.create_token(
    token_type="request",
    erin="Translate 'hello' to Dutch",
    eraan=[],
    eromheen='{"user": "alice"}',
    erachter="User wants translation",
    actor="user_001"
)

# Child response (linked to parent)
response = engine.create_token(
    token_type="response",
    erin="Hallo",
    eraan=["gpt-4"],
    eromheen='{"latency_ms": 150}',
    erachter="Translation completed",
    actor="ai_agent",
    parent_id=request.id  # Chain link!
)

print(f"Parent: {request.id}")
print(f"Child parent_id: {response.parent_id}")  # Same as request.id

Why TIBET?

Regulatory Compliance

• GDPR Article 22 (automated decision-making)
• EU AI Act (transparency requirements)
• SOC 2 / ISO 27001 (audit trails)

6G Ready

• Designed for AI-native networks (ITU IMT-2030)
• Referenced in IETF 6G AI agent drafts
• Minimal footprint for edge devices

Cryptographically Secure

• Ed25519 signatures
• Tamper-evident chains
• Verifiable without central authority

Size Comparison

Component	Size
tibet-core (Rust)	~50KB
tibet-core (WASM)	~100KB
tibet-core (Python wheel)	~2MB
Linux kernel (minimal)	~300KB

IETF Standardization

TIBET is being standardized at the IETF:

• draft-vandemeent-tibet-provenance - Evidence Trail Protocol
• draft-vandemeent-jis-identity - JTel Identity Standard

W3C Alignment

TIBET aligns with W3C standards:

• Verifiable Credentials 2.0 - Token structure compatible
• Decentralized Identifiers (DIDs) - Actor identification
• JSON-LD - Semantic context in EROMHEEN

Architecture

┌─────────────────────────────────────────────────────────────┐
│                    TIBET ECOSYSTEM                          │
├─────────────────────────────────────────────────────────────┤
│   ┌─────────────────┐                                       │
│   │  tibet-core     │  ← 50KB Rust, minimal deps           │
│   │  (the kernel)   │    create_token, verify, chain       │
│   └────────┬────────┘                                       │
│            │                                                │
│   ┌────────┴────────┬──────────────┬──────────────┐        │
│   ▼                 ▼              ▼              ▼        │
│ tibet-c        tibet-wasm    tibet-python   tibet-js       │
│ (embedded)     (browser)     (PyPI)         (npm)          │
└─────────────────────────────────────────────────────────────┘

Credits

• Specification: Jasper van de Meent (Humotica)
• Implementation: Root AI (Claude) & Jasper van de Meent
• License: MIT OR Apache-2.0

Links

• Humotica
• IETF TIBET Draft
• IETF JIS Draft
• PyPI
• npm

---

"The Linux of AI Provenance" - Making audit trails as universal as the kernel.