HUMMBL is open-source governance infrastructure for agentic AI: scoped delegation, kill switches, circuit breakers, and verifiable receipts that run inside your Python environment.
pip install hummbl-governance
// THE PROBLEM
AI agents are now booking flights, executing trades, writing code, and managing infrastructure autonomously. Frameworks like LangChain, CrewAI, and AutoGen make it easy to build agents that reason, plan, and act. But as agents gain autonomy, a critical question emerges: who governs what they do?
Policy documents don't stop a runaway call. Spreadsheets don't explain an action after the fact. You need controls in the execution path and records that survive runtime.
// PACKAGE PROOF & EVIDENCE
Scope: verified snapshot at tag hummbl-governance/v1.4.2 (commit b1b0581). In CI run 32904924444, the repository suite reported 2,463 passed, 3 skipped on Python 3.13. This is source-commit CI evidence, not a production-use receipt. The public oss CI workflow runs Python 3.13 only and does not collect coverage. The published v1.4.2 package is classified Alpha while public interfaces stabilize. Inspect the claim ledger and sources.
// ARCHITECTURE
HUMMBL organizes 34 governance primitives from hummbl-governance into three layers that sit directly in the agent execution path. Authority scopes what an agent can do. Containment bounds what happens when things go wrong. Evidence proves what actually happened.
HMAC-SHA256 delegation tokens bind issuer, subject, task, contract, permitted operations, resources, and expiry inside a shared-secret trust domain.
Kill switches, circuit breakers, capability fences, and cost governors can block or bound execution when your application places them on the action path.
Append-only records and HMAC receipts make integrity and authenticity checkable by parties that hold the shared key.
// END-TO-END PROOF
This example runs against the package API. It validates delegated authority, executes a bounded action, stores one receipt whose authenticated payload contains CONTRACT × DCT × EVIDENCE, and then verifies both the receipt and its local chain.
import hashlib
import secrets
from pathlib import Path
from tempfile import TemporaryDirectory
from hummbl_governance import DelegationTokenManager, ReceiptEngine
secret = secrets.token_bytes(32) # Load a stable key in production.
contract = {"id": "summary-v1", "operations": ["summarize"]}
task_id = "task-42"
# AUTHORIZE — issue and validate scoped delegated authority.
tokens = DelegationTokenManager(secret)
dct = tokens.issue(
issuer="orchestrator",
subject="summarizer-agent",
operations=contract["operations"],
resources=["docs/report.md"],
task_id=task_id,
contract_id=contract["id"],
)
allowed, reason = tokens.validate_token(
dct,
expected_task_id=task_id,
expected_contract_id=contract["id"],
expected_subject="summarizer-agent",
)
assert allowed, reason
# EXECUTE — your runtime performs the authorized action.
source = "Bounded authority makes agent actions reviewable."
result = " ".join(source.split()[:5])
# RECORD + BIND + VERIFY — authenticate the tuple and verify its chain.
with TemporaryDirectory() as state:
receipts = ReceiptEngine(Path(state), signing_secret=secret)
receipt = receipts.create_and_store(
agent_id=dct.subject,
action_type="summarize",
payload={
"contract": contract,
"dct": dct.to_dict() | {"signature": dct.signature},
"evidence": {
"outcome": "completed",
"output_sha256": hashlib.sha256(result.encode()).hexdigest(),
},
},
)
assert receipts.validate(receipt)
assert receipts.verify_chain(dct.subject)[0]
assert len(receipts.list_for_agent(dct.subject)) == 1
// OWASP AGENTIC AI TOP 10
OWASP published the Top 10 for Agentic Applications in December 2025 — the first formal taxonomy of risks specific to autonomous AI agents. HUMMBL primitives address each risk category when placed in the execution path.
Contract enforcement binds agent actions to declared task scope.
Capability fences restrict which tools an agent may invoke per delegation.
HMAC delegation tokens cryptographically bind issuer, subject, and task.
Zero third-party runtime dependencies. Stdlib-only Python. Apache 2.0 license.
Kill switch terminates agents instantly. Execution rings limit resource exposure.
Append-only audit log detects tampering. Chain verification proves integrity.
HMAC receipts authenticate inter-agent messages within the shared-secret trust domain.
Circuit breakers isolate failing agents. Cost governors bound resource consumption.
Approval workflows require human sign-off for high-risk operations.
Kill switch terminates rogue agents. Delegation expiry prevents stale authority.
// FRAMEWORK INTEGRATIONS
HUMMBL governance primitives are stdlib-only Python. They drop into any agent framework without rewriting your code. Each integration hooks into the framework's native extension points.
// HOW WE COMPARE
GRC tools document AI in spreadsheets but can't see agents at runtime. Security tools watch agents but can't sanction them. HUMMBL puts governance primitives directly in the execution path.
// CHOOSE YOUR PATH
Inspect the 34-primitive inventory, install the Alpha package, and evaluate the controls against your architecture and threat model.
Review the evidence and assurance limits first. HUMMBL can help map controls into your deployment without treating a library as a substitute for organizational governance.
// ASSURANCE BOUNDARY