Portable, replayable, and verifiable accountability runtime for AI agents, tools, workflows, delegation systems, and cross-runtime execution environments.

JEP / HJS / JAC is a layered protocol and runtime stack for:

• replayable judgment events
• verifiable delegation lineage
• portable accountability receipts
• dependency-chain reconstruction
• authority propagation semantics
• cross-system accountability interoperability

The stack acts as a neutral narrow-waist accountability layer between:

Human / Organization Intent
              ↓
        Agent Runtime
              ↓
      Tool / Workflow Execution
              ↓
      Delegation Propagation
              ↓
      Verification and Replay

These integrations allow:

• replayable execution traces
• delegation lineage reconstruction
• verifiable accountability propagation
• runtime verification semantics
• execution replay reconstruction

Human / Organization
        ↓
Agent Runtime
        ↓
JEP Runtime Middleware
        ↓
Judgment / Delegation Events
        ↓
HJS Accountability Receipts
        ↓
JAC Dependency and Lineage Graph
        ↓
Archive + Replay Verification

Human
  ↓
OpenAI Agent
  ↓
MCP Tool Execution
  ↓
JEP Judgment Event
  ↓
HJS Accountability Receipt
  ↓
JAC Delegation Chain
  ↓
Archive Storage
  ↓
Replay Verification

As AI systems become increasingly autonomous, accountability becomes a runtime problem.

Modern AI systems increasingly involve:

• multi-agent delegation
• tool execution
• workflow orchestration
• cross-runtime automation
• autonomous task propagation
• delegated authority chains
• replay-sensitive execution semantics

Without portable accountability semantics:

• delegation chains become opaque
• authority propagation becomes unverifiable
• replay and audit become fragmented
• cross-agent responsibility becomes non-portable
• runtime lineage becomes difficult to reconstruct

JEP Runtime Stack provides a replayable accountability execution layer for AI systems.

JEP is NOT ordinary logging.

Traditional logging records events.

JEP Runtime provides:

• replayable accountability semantics
• delegation lineage reconstruction
• authority propagation tracking
• portable verification
• replay-safe execution traces
• cross-runtime accountability interoperability

JEP events are:

• canonicalized
• hash-linked
• replay-verifiable
• delegation-aware
• portability-oriented

The stack is designed to enable replayable accountability semantics, not just event storage.

pip install jep-runtime

from jep_runtime import JEPMiddleware

runtime = JEPMiddleware()

@runtime.wrap_tool("search")
def search_tool(query):
    return f"search result for {query}"

result = search_tool("JEP Runtime")

This automatically produces:

• Judgment Events
• Delegation Events
• Verification metadata
• Replayable accountability chains

Replayable accountability is a core design principle.

Any archive can be replayed and verified:

jep replay archive.jsonl

Verification includes:

• delegation lineage
• event hash continuity
• authority propagation
• verification chains
• tamper detection
• replay integrity validation

JEP      = atomic signed judgment events
JEP API  = event creation and verification runtime
HJS      = accountability receipts and evidence lifecycle
JAC      = declared dependency and delegation lineage
Runtime  = executable accountability semantics
SDKs     = developer integration surface
Adapters = runtime insertion into agent ecosystems
Replay   = accountability reconstruction and verification

Historical repositories (v0.4 lines and early demos) should be treated as historical design artifacts unless explicitly marked current.

The JEP Runtime Stack provides infrastructure for:

• recording judgment-related events
• replayable delegation lineage
• portable accountability semantics
• verifiable event chains
• accountability receipts
• dependency reconstruction
• cross-system interoperability
• runtime accountability integration
• replay verification
• authority propagation semantics

This stack does NOT determine:

• external truth
• legal liability
• moral responsibility
• regulatory compliance
• factual correctness
• authorization validity
• complete-log guarantees

A valid signature proves cryptographic integrity under a validation profile.

It does NOT prove that an underlying claim is true.

A valid delegation chain proves declared accountability structure.

It does NOT prove legal causality or liability.

The stack follows:

• protocol-layer data minimization
• replay-safe canonicalization
• explicit validation semantics
• optional privacy-preserving archival
• selective disclosure
• append-only accountability chains
• explicit trust and audience boundaries

The stack is intentionally:

• protocol-minimal
• runtime-portable
• identity-neutral
• credential-neutral
• replay-oriented
• interoperability-first
• accountability-focused
• execution-path aware

• Email: signal@humanjudgment.org
• Issues: use the issue tracker of the relevant repository