← redevops.io  /  Benchmarks  /  Open vs Enterprise model-free · reproducible
Open-core · what does Enterprise add?

Open vs Enterprise, measured

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 — so we run the same workloads through the open (AGPL) runtime and the Enterprise runtime and classify every difference under one 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.

Every differential is therefore exactly one of three things:

PARITY — same execution result (state, nodes, scheduling), bounded overhead.   HARDENED_DELTA — 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.

Experiment 1 — Enterprise must not change execution

The parity-required families: orchestration and safe concurrency. Run through both editions with hardening off, the execution must be identical.

Same workload, both editionsOpen (AGPL)Enterprise (hardening off)Verdict
Orchestrationfan-in DAG, 5 nodes, pure compute succeeded · 5 nodes · 31 events succeeded · 5 nodes · 31 events PARITY
Safe concurrency2 prod + 1 staging deploy; two prod writes conflict 3 nodes · serialized
k8s:cluster:prod at limit 1
3 nodes · serialized
k8s:cluster:prod at limit 1
PARITY

Same final state, same committed nodes, the same scheduling decision (the second prod deploy serialized behind the first, same auditable reason), same event vocabulary. Zero divergence.

Experiment 2 — Enterprise should change enforcement

An enterprise-delta family: a governed 5-step mission with a consequential, permissioned send. Here the Enterprise Identity Plane is enabled (a principal, deny-by-default grants, a hash-chained access ledger).

Governed mission · Enterprise, hardening onExecution resultAdded guaranteesVerdict
Authorized principalrole granted outreach:send · crm:write same 5 nodes
(correctness preserved)
+5 hash-chained audit entries
+2 verification records
HARDENED_DELTA
Unauthorized principaldeny-by-default — no grant 0 nodes executed
mission blocked
declared policy prevented
every side effect
HARDENED_DELTA
Unauthorized executions preventeddeny-by-default at the capability boundary — 0 side-effecting nodes ran.
Audit events addedan append-only, hash-chained access ledger (tamper-evident), one entry per authorized dispatch.
Verification records addedconsequential results verified before they become authoritative state.
Policy decisions enforcedthe block is a declared identity-plane decision, not a crash.

The cost of hardening

Guarantees have a price, so we report the price beside the guarantee (governed mission, median of 15 reps).

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 — no performance claim is made from them. The point is that the cost is reported, and it grows as more planes are enabled (Identity, ledger, verification, and later Vault / lakehouse / security plugins).

The open-core story this measures

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

The hardening is additive, not a fork of the execution semantics.

Both editions execute and schedule concurrency identically; the Enterprise edition then enforces authority, records tamper-evident evidence, and verifies consequential state on top — each a distinct, measured delta. A workload that needs none of it pays nothing; a workload that needs all of it gets deny-by-default, a hash-chained ledger, and verified state, without changing how the mission runs.

Retrieval / context familiesbasic RAG, context pollution, long-context, incremental recompute and representation routing traverse the Context Runtime / RAG / Discovery, not the mission-runtime hardening path — so they are parity by construction (the Enterprise Context runtime is a separate differential).
Cross-language, nextthe open safe-concurrency contract is already conformance-tested across Python, Go and Kotlin. The same "one contract, N implementations" test should apply to authority, audit and verification as they gain Go/Kotlin implementations — rather than becoming Python-only enforcement.

// reproduce · model-free · runs anywhere
AGPL_ROOT=<agentic-os> ENT_ROOT=<agentic-os-src> python -m workloads.enterprise_differential.run
→ parity-required all PARITY · enterprise-delta all HARDENED_DELTA · no BUG  ·  read the short write-up →