← redevops.ioarchitecture →
Enterprise Edition

Open contracts.
Private production enforcement.

Enterprise plugins satisfy the public runtime seams by shape and are injected at deployment; the open engine never imports proprietary code.
The source-available runtime defines the contracts, execution model, security semantics, telemetry protocol, and integration seams. Enterprise plugins implement the production enforcement behind those seams — sandboxing, credential brokerage, containment, OpenTelemetry correlation, deployment adapters, and enterprise platform integrations.

What is it?

Private production plugins that enforce the open runtime contracts.

Why would I need it?

Security enforcement, telemetry export, containment, credential brokerage, deployment integration, and enterprise runtime/platform support.

What stays open?

The canonical contracts, event shapes, runtime seams, and reference implementations.

Security and telemetry are runtime semantics; Enterprise plugins are their production enforcement and export implementations. The open runtime never imports enterprise code — plugins consume the same public, versioned contracts and can only tighten them, never redefine them.

Source-available vs. Enterprise Edition

Source-available runtimeEnterprise Edition
Runtime contracts & protocolsHardened enforcement implementations
Discovery / Mission / Context runtimesIntrinsic security enforcement
Canonical security event shapesSandbox + credential broker
TraceContext / telemetry protocolOTel bridge + SIEM / export
Governance semanticsCorrelation + containment
Public reference implementationsArgo / enterprise deployment adapters
Python reference runtimeGo / Kotlin / .NET enterprise runtimes
Self-hostable under AGPLCommercial licensing + support / integrations

One canonical event

Security, telemetry and governance all subscribe to the same canonical runtime event (RuntimeSecurityEvent + the Mission-rooted TraceContext), so no plugin ever invents a subtly different event meaning. The runtime produces the facts; the plugins act on them.

                    Canonical Runtime Event        (open: runtime-contracts)
                    RuntimeSecurityEvent + TraceContext
                              │
        ┌─────────────────────┼──────────────────────┐
        ▼                     ▼                      ▼
   security-enterprise    runtime-telemetry      governance (open)
   sandbox · broker       store · gov · OTel
   monitor · corpus            │
   identity · wiring           ▼  OpenTelemetry export
                          deployment-argo ──► Argo / K8s / app spans ──► Tempo / Jaeger
                          (nested UNDER the Mission node — never over it)

How enforcement plugs in

Every plane is a plain object that satisfies an open typing.Protocol by shape and is passed into a constructor (or one process-wide setter) — no entry-points, no discovery magic. The open engine never imports a plugin; a plugin imports only the open types. Absent a plane, behaviour is unchanged; but a capability that declares isolation, required authority, or a digest pin with no plane wired fails closed rather than running unconfined. Nothing here weakens the open contract — it only enforces it.

Security

runtime_security_enterprise

Intrinsic-security enforcement: sandbox, credential broker, correlation/containment, adversarial corpus, identity.

Telemetry

runtime_telemetry

Canonical Mission telemetry + the OpenTelemetry bridge. Native record is truth; OTel is export.

Deployment

deployment_argo

Argo Workflows adapter — nests substrate spans under the Mission node; behind a beta version guard.

Evidence Lakehouse

evidence_lakehouse

Durable historical system of record for canonical runtime evidence. Behind the open EvidenceStore seam; managed-DB / warehouse / lakehouse backends are pluggable.

Secrets & Credentials

credentials_vault

Vault/OpenBao production broker: dynamic credentials, leases, revocation, rotation, Transit signing. Behind the open CredentialBroker seam.

1 · Security enforcement

The canonical security contracts are open — a deny-wins SecurityDecision, an AuthorityContext delegation chain that only ever narrows, boundary-emitted RuntimeSecurityEvents, JIT CredentialGrant references, a Containment state machine, and the adversarial-validator interface. This plugin is the enforcement behind them:

PlaneWhat it enforces
SubprocessSandboxThe confinement behind the Sandbox seam — network-deny, privilege drop, immutable input snapshot, secrets never serialized in the clear (via redact()). Its profile derives from the open canonical ExecutionConstraint and by default it composes the open rootless reference membrane — so it inherits the AGPL containment floor and adds the hardened tier (OS namespaces / microVM / remote attestation) over the same one spec, never a second containment model. A capability declaring isolation with no sandbox wired fails closed.
VaultCredentialBrokerJust-in-time credentials: lease-gated so a credential can never widen the leased authority, minted as a reference (scope · authority · material hash), redeemed out of band — no secret ever enters a plan/context/fingerprint.
SecurityPlaneWraps the boundary monitor with tenant-tuned correlation thresholds, drives the containment state machine off the correlated disposition, and exports each disposition to a redacted SIEM sink (ids + hashes, never payloads).
AdversarialCorpusExtends the open validators (evidence may influence belief, never grant itself authority) with an OWASP-LLM-tagged pattern corpus; returns a decision plus the OWASP categories tripped.
PolicyPlane / TrustPlaneABAC feasibility + trust weighting that satisfy the Context Runtime planner seams — narrowing the feasible plan space before ranking.
action ─► boundary telemetry ─► SecurityTrajectory ─► correlate() ─► disposition ─► Containment
                                                          │
   individually-permissible calls (read PII, then egress) │  correlate into DENY (exfiltration shape)
                                                          ▼
                              RUNNING ─► CONTAINING ─► CONTAINED ─► REVIEW ─► RECOVERED
                              (NO_OVERRIDE contains and refuses any later recovery)

2 · Telemetry — the OpenTelemetry bridge

A ReDevOps Mission is the root of one causal trace. Discovery, planner decisions, context/evidence choices, governance verdicts, capability invocations and reconciliation are spans in one tree rooted at the Mission; a deployment substrate nests underneath the node that caused it. The trace identity (a W3C-compatible TraceContext) is minted by the Mission and only ever propagated down, and its ids are content-addressed so a replay reproduces the exact trace. Native telemetry is the semantic source of truth; OpenTelemetry is the interoperability layer.

The TelemetryBridge projects the Mission's boundary-emitted event stream into that span tree and fans it — the same record — to three sinks: the event/artifact store, the governance/security planes, and an OTLP exporter. The OpenTelemetry dependency is isolated behind an optional extra, so the bridge is always importable and testable; with no collector it degrades to emitting the canonical span dicts.

Mission 7F21
├── Discovery
├── Planner
├── Node: deploy service
│   └── (substrate nests here — Argo/K8s/Terraform/cloud/edge)
├── Verification
└── Reconciliation

one causal tree answers both:  "why did we decide to deploy?"  →  "which pod/artifact took 4 seconds?"

3 · Deployment adapters — Argo (and the others)

Argo 4.1 emits OpenTelemetry traces across controller reconciliation, DAG scheduling, pod creation, synchronization, artifact handling and executor activity — excellent infrastructure-level visibility, but it describes how the Kubernetes machinery ran, not the semantic meaning of a Mission. So deployment-argo treats Argo as a child substrate under the Mission node:

It sits behind a version guard because Argo's own tracing is labelled beta and may change incompatibly: below Argo 4.1 (or with no collector) it degrades to baggage-only propagation, so the Mission telemetry contract is never bound to Argo's current span schema. And Argo is one adapter among many — ReDevOps keeps identical Mission semantics whether deployment runs through Argo, raw Kubernetes, Terraform, GitHub Actions, a cloud API, a local runtime, an edge device, or SSH. OTel correlation is on by default; the substrate adapter is optional per backend.

The result: Argo provides excellent infrastructure-level visibility, while ReDevOps retains the higher-level semantic record that makes security, replay, governance and optimization possible — Argo 4.1 as a first-class telemetry adapter, not the default telemetry architecture.

4 · Historical Evidence Plane — the Evidence Lakehouse

Long-term evidence, not just logs. Enterprise Edition can persist canonical runtime decisions, security events, traces, approvals and execution history into an immutable analytical lakehouse for audit, replay, governance and historical context — while the open runtime remains storage-neutral through public EvidenceStore contracts.

The runtime keeps two distinct kinds of truth, and never conflates them. The Hot Ledger is authoritative operational state — what gates, replay, reconciliation, approvals and current projections run against. The Evidence Lakehouse is the durable historical system of record for canonical events, telemetry, security evidence and governance history. The lakehouse never sits in the synchronous decision path; it is fed from the event bus, and OpenTelemetry/SIEM are parallel real-time exports, not the durable truth.

Runtime ─► Hot Ledger ─► Event Bus ─► Enterprise Evidence Lakehouse   (durable system of record)
                            └───────► OTel / SIEM                     (parallel real-time export)

It persists the whole canonical lifecycle — mission_events, discovery_evidence, verified_intents, plan_artifacts, context_decisions, capability_events, security_events, governance_dispositions, approvals, execution_events, reconciliation_results, trace_spans, policy_versions — so it answers the cross-plane question "what did the system know, decide, authorize, execute and observe?" rather than being a security archive. Event identity and artifact identity are separate first-class columns, so causal traversal, bitemporal reconstruction, dedup and tamper verification never require decoding a payload.

The open seam expresses capabilities, not a table format — append · resolve · snapshot(as_of) · changes(since) · scan · verify — so the enterprise implementation can be Iceberg/S3, Hudi, Delta, a managed relational database, or a warehouse, all interchangeable and none named in the contract. A large number of standalone or managed relational databases and lakehouse schemas can serve as the storage layer through the pluggable backend registry: the runtime depends on the capability, the deployment chooses the backend. Persistence schemas are projections of versioned runtime contracts through an explicit projection layer — so lakehouse layout evolves without being chained to every protocol edit.

Source-available runtime (AGPL)Enterprise Edition
Canonical contractsDurable Evidence Lakehouse
JSONL / file ledgerKafka / stream ingestion
Local artifact / file storeS3 / MinIO object storage
EvidenceStore / ContextStore protocolsIceberg / Hudi / managed-DB implementations
Local replayLong-horizon historical replay
File-level telemetryRetention / legal hold / lifecycle policies
Open query adaptersSpark / Databricks / Trino integrations
Content hashesTamper verification at scale
Basic exportSIEM / data-platform export pipelines

Once the lakehouse is behind EvidenceStore, historical runtime behaviour becomes Context-Runtime-readable evidence — closing a loop from execution → canonical evidence → lakehouse → historical retrieval → future planning and governance. That loop has a hard boundary: retrieved history is never silently authoritative — it carries provenance/freshness/trust and passes the same Discovery/Context validation as any other evidence source. Retention classes are per event family (traces expire sooner than approvals or policy decisions; regulated missions can be placed under legal hold).

See it live. The Evidence Explorer persists a real benchmark run through the open EvidenceStore seam and lets you query the saved canonical evidence.

5 · Secrets & Credential Brokerage

Secrets never enter AI context. Capabilities receive short-lived, authority-scoped credential grants only at the execution boundary. Enterprise adapters integrate Vault/OpenBao for dynamic credentials, leases, revocation, rotation and non-exportable signing keys.

The commercial differentiation is not "we bundled Vault." It is that the runtime knows which Mission, node and capability is allowed to use which credential, issues the narrowest possible grant at the last responsible moment, records that authority was exercised, and keeps the secret itself out of context, plans, telemetry, replay and historical storage. A raw secret is never serialized into a plan, VerifiedIntent, evidence, prompt, telemetry event, trace attribute, replay artifact, fingerprint, or Evidence Lakehouse record — only a SecretRef and a CredentialGrant reference travel; SecretMaterial is redeemed at the boundary and destroyed after use.

Mission / Planner ──► CredentialRef only
        │
        ▼   grant = Mission authority ∩ capability requirement ∩ credential policy   (only ever narrows)
   CredentialBroker ──► narrow, time-bound CredentialGrant
        │
        ▼   redeemed ONLY at the capability boundary, inside the sandbox
   SecretMaterial in process memory ──► discarded after invocation

Canonical safe events (grant issued · redeemed · revoked · denied) ──► Security / Governance / OTel / Lakehouse
                                                                        (secret_ref_hash + authority_hash, never the secret)

The open runtime ships the contracts (SecretRef, CredentialRequirement, CredentialGrant, the SecretStore / CredentialBroker / KeyService seams), the redaction rules, the canonical credential events, and development-grade env / file providers with a LocalCredentialBroker. A capability that declares production_broker_required and finds only a development broker fails closed — it does not run. That boundary is exactly where the enterprise broker lives.

Source-available runtime (AGPL)Enterprise Edition
SecretRef / CredentialBroker / KeyService contractsVault & OpenBao adapters
Authority narrowing + fail-closed semanticsProduction JIT broker + lease orchestration
Env / File dev providers + local brokerDynamic secret engines (DB / cloud IAM / PKI / SSH)
Canonical credential events + redactionDistributed revocation + containment-driven mass revoke
Reference tests + adversarial suiteTransit / KMS non-exportable signing · rotation · SIEM · HA

Open SecretRef and CredentialBroker contracts; private production enforcement. Vault/OpenBao provide the secret-management substrate underneath the runtime-native authority model — never a dependency of the runtime.

Evidence — does it work?

Enterprise controls are measured, not asserted. The plugins are scored against public labeled datasets and recorded trajectories, with misses reported alongside hits. Headline results so far:

See it live. The intrinsic-security showcase runs the real monitor over a scenario — per-call decisions, boundary telemetry, and a series of individually-allowed calls correlating to DENY / CONTAINED — beside the data-access permissions plane.

Want to see whether it works? Enterprise Benchmarks →

Open-core by design. ReDevOps publishes the runtime contracts, protocol shapes, reference runtimes, and reproducible public examples under AGPL — the fully inspectable foundation and adoption path. Enterprise Edition is where ReDevOps packages the production enforcement, integrations, hardened deployment components, and commercial support we maintain for organizations operating consequential AI systems. There is no separate "enterprise architecture": one open protocol, with stronger private enforcement behind the same seams. See the security model, the governance plane, and the canonical contracts.
ReDevOps Enterprise Edition — production enforcement for the open runtime. Open contracts, private enforcement. © 2026 redevops.io