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.
The cost, reported beside the guarantee
| Mode | Correctness | Security | Audit | Verification | Latency |
|---|---|---|---|---|---|
| Open (AGPL) | ✓ 5 nodes | baseline | none | 2 records | ~0.38 ms |
| Enterprise, hardening off | ✓ 5 nodes | same | none | 2 records | ~0.29 ms |
| Enterprise, hardening on | ✓ 5 nodes | deny-by-default | 5, hash-chained | 2 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.