All articles
    open-core
    enterprise
    mission-runtime
    governance
    security
    audit
    benchmarks
    agpl

    What Does the Enterprise Runtime Actually Add?

    August 30, 2026redevops.io
    What Does the Enterprise Runtime Actually Add?

    Open-core infrastructure has an uncomfortable question to answer: what exactly changes when you move from the source-available version to Enterprise?

    The wrong answer is a feature checklist.

    We wanted a measurable one.

    One rule, three verdicts

    So we run the same workloads through the open (AGPL) runtime and the Enterprise runtime, and hold every difference to a single falsifiable rule:

    Enterprise may add enforcement, evidence, and verification; it must not silently change the open execution result unless a declared enterprise policy blocks or modifies that execution.

    That turns every differential into exactly one of three things:

    • PARITY: same execution result (state, nodes, scheduling decision), bounded overhead. Expected.
    • HARDENED_DELTA: the result differs because a declared policy intervened, or the result is the same and Enterprise added enforcement / evidence.
    • BUG: the result differs with no policy intervention. Unexplained divergence: it fails.

    Then just two experiments.

    Experiment 1: Enterprise must not change execution

            Open (AGPL)                  Enterprise
            5-node mission               5-node mission
            same final state             same final state
            same scheduling              same scheduling
            same concurrency conflicts   same concurrency conflicts
                              ↓
                           PARITY
    

    Orchestration and safe concurrency come back identical: same final state, same committed nodes, and the same scheduling decision (two writes to the same resource key serialize behind each other, with the same auditable reason: resource_key=k8s:cluster:prod at limit 1). No divergence.

    Experiment 2: Enterprise should change enforcement

    Now a governed five-step mission with a consequential, permissioned send, run through the Enterprise Identity Plane:

       Authorized                        Unauthorized
       open execution                          ↓
            ↓                             Enterprise
       Enterprise                         0 nodes executed
       same execution                     declared policy blocked
       + authority enforcement            execution
       + hash-chained audit
       + verification
    

    The authorized run commits the same five nodes (correctness preserved) and adds five hash-chained audit-ledger entries and verification records. The unauthorized run executes zero nodes: a declared deny-by-default policy prevents every side effect. Both are HARDENED_DELTA: different (or annotated) because a policy said so, never silently.

    Two experiments: with hardening off the open and enterprise runtimes execute identically (PARITY); with hardening on, an authorized mission keeps the same execution and adds authority enforcement, a hash-chained audit ledger and verification, while an unauthorized mission runs zero nodes because a declared policy blocks it (HARDENED_DELTA).
    Scroll the diagram sideways to read itFull size

    The cost, reported beside the guarantee

    ModeCorrectnessSecurityAuditVerificationLatency
    Open (AGPL)✓ 5 nodesbaselinenone2 records~0.38 ms
    Enterprise, hardening off✓ 5 nodessamenone2 records~0.29 ms
    Enterprise, hardening on✓ 5 nodesdeny-by-default5, hash-chained2 records~0.34 ms

    At this workload size the latency differences are effectively below the noise floor, so we make no performance claim from them. The point is that the cost is reported, and it grows as more planes come on (Identity, ledger, verification, and later Vault, lakehouse, and security plugins).

    The line worth keeping

    The hardening is additive to the execution semantics.

    That is exactly what the benchmark demonstrates. It also gives the open-core story a cleaner formulation than the usual "the free version is a demo":

    The open runtime defines and implements the execution semantics. Enterprise preserves those semantics while adding production enforcement, evidence, identity, audit and operational infrastructure.

    The open runtime is real: it executes real workloads, with safe concurrency, replay, and context management. Enterprise preserves how it runs and makes the guarantees around that run enforceable.


    The full tables, methodology, classification rules and reproduce command are on the Open vs Enterprise benchmark page. Model-free: it runs anywhere.

    Want ReDevOps in your Google Top Stories & AI results?Follow ReDevOps on Google