HUMMBL Typed Tuples

Typed governance tuples for bounded delegation, evidence, and execution control in AI-native systems.

The governance tuple is the minimal atomic record that proves a governed AI decision happened — not that someone claimed it did.

Scientific Grounding

This repo also defines the tuple pattern for scientific grounding:

• EVIDENCE for source-grounding and claim-linkage events
• ATTEST for distinct verifier review of that evidence
• PROMOTION_RECEIPT only for later promotion decisions

See SCIENTIFIC_GROUNDING.md and the examples:

• examples/evidence.scientific-source-grounded.json
• examples/attest.scientific-source-grounded.json

Layered Envelope (TUPLES v2)

All tuples use a layered envelope. Lower layers are universal; higher layers apply only where governance semantics are needed.

VERUM's 4 node fields (id, time, state, drift) are deliberately split: id/time establish existence (universal), while state/drift establish judgment (governance-specific). See TUPLES_v2.md §8 for the rationale.

Tuple Taxonomy

Six governance tuple types (Layer 1 + 2 + 3/IDP):

Two additional governance-control tuple types are included for distributed mesh operations:

Plus three research/experiment families (Layer 1 + 3, no governance overhead):

• BaseN (8 types): reasoning experiment instrumentation
• Nodezero (4 types): experiment control tuples
• Bio (11 types, experimental): bio-cognitive signal tuples

Quick Start

# Validate all examples against schemas
make validate

# Run the test suite
make test

# Run the governance simulation
make simulate
python3 test_simulation.py

Requires Python 3.10+. Zero third-party runtime dependencies (stdlib only).

Canonical versioned taxonomy:

• TYPED_TUPLE_TAXONOMY.md

Repo Layout

docs/specs/          Canonical tuple specs (TUPLES_v2 is current)
schemas/             JSON Schemas for tuple classes (21 core)
schemas/experimental Bio-governance schemas (11, not yet promoted)
examples/            Sanitized tuple examples (26 fixtures)
hummbl_tuples/       Python reference implementation
  simulation/        Deterministic governance simulation prototype
reference_impl/      Stdlib-only validators
comparisons/         Tuple vs adjacent approaches
research_notes/      Hypotheses, experiments, open questions
novelty_quest/       Candidate claims, objections, negative results
adrs/                Architectural decision records (4 ADRs)

Governance Simulation

A deterministic rule-based governance simulator exercises the tuple schemas as an execution surface. It models a multi-agent system with delegation, probation, scope denial, and recovery — producing 29-event traces that validate against the JSON Schemas.

make simulate                                          # scalar trace summary
python3 -m hummbl_tuples.simulation --out /tmp/trace.json  # full JSON trace
python3 test_simulation.py                             # regression assertions

The simulator is bitwise-deterministic under a fixed seed, enabling reproducible parameter sweeps.

Publication

This repo is the companion artifact for:

• "The Governance Tuple: An Atomic Record for Auditable Agentic AI Decision-Making" — formalizes the (CONTRACT, DCT, EVIDENCE) triple and proves four accountability properties
• "A Typed Delegation-Governance Tuple Profile for Multi-Agent Runtime Control" (CRAI 2026) — the six-tuple IDP profile with composability evidence
• "Append-Only as Proof" — the VERUM governance sovereignty framework

ORCID: 0009-0002-5620-1103

Key Design Decisions

Related

• Runtime implementation: the production BaseNTuple dataclass lives in a separate repo (HMAC-SHA256 signing, JSONL persistence, tier classification as policy-as-code)
• VERUM: append-only audit sovereignty framework — 4 invariants for governance proof
• Base120: governed reasoning vocabulary — 120 operators in 6 families

License

Apache 2.0. See LICENSE and NOTICE.