ReDevOps is not a collection of runtimes. It is one production AI control and execution platform, with three specialized runtimes (Discovery, Mission, Context), one Execution Planner, one control plane (Projects + Sidekick), and a shared capability plane. The Execution Planner is a planner, not a runtime — it has no independent persistent lifecycle or deployable service of its own. Discovery spans two facets — signal discovery (world-state → MissionProposal, below) and intent discovery (requester language → a sealed VerifiedIntent), the latter now an extracted standalone runtime shared across applications.
A goal flows top to bottom. Mission Runtime owns the execution graph; Context Runtime supplies intelligence to its nodes. They are not competing orchestrators — Mission runs the workflow, Context optimizes what each node knows.
The stack above is the platform's internal anatomy. What a developer builds against is one boundary over it: the Mission SDK — author a mission and its capabilities declaratively — and Mission DevOps, a rdo mission CLI (validate · explain · profile · simulate · run · verify · ci · bundle · replay · diff · init, where profile is EXPLAIN ANALYZE for a mission). This boundary — not any internal module — is the stable surface, and it now ships: the public redevops-mission package exposes redevops_mission.* over the internal agentic_os.mission.* engine, with rdo doctor for a one-command environment check, and durable stores plus resume_program to continue a parked mission after a restart (v0.3.x). It is installed from the git repository today (not yet on PyPI). It is the stack's public front door — wrap an existing LangGraph, LangChain or custom agent as a capability and run it as a governed, replayable mission, no framework rewrite — and the one public artifact a developer holds is a versioned MissionProgram. Alpha (0.2.x): the contract is settling, the surface is real.
Two consequences the rest of this page assumes:
MissionProposal both compile to the same MissionProgram — Discovery proposes, it never executes — so every mission is replayable and verifiable by construction, whoever authored it.MissionProgram yields identical validate / simulate / run / replay / verify outcomes and reproduces the golden contract fixtures — the SDK contract is the compatibility target, not line-for-line internals.One responsibility table, so no two pages describe the same behaviour twice.
| Component | Answers | Owns | Does not own |
|---|---|---|---|
| Discovery Runtime | Which changes deserve a mission? | World-state observation, StateDelta, detectors, correlation/suppression, hypotheses, opportunity/risk ranking, proactivity budgets, mission proposals, safe policy learning | Execution — it proposes missions, it never acts |
| Execution Planner | What complete plan should run? | Representation selection, retrieval/reasoning/model plan, execution topology, budgets, verification & governance plan, fallbacks — one explainable ExecutionPlan | Persistent lifecycle/APIs of its own — it is a planner, not a runtime |
| Mission Runtime | How does a goal become safe, durable execution? | The execution graph, state transitions, scheduling, retries, human gates, simulation, a tamper-evident (append-only, hash-chained) evidence & event ledger, verification, event sourcing, deterministic replay/resume, compensation (saga), budgets/deadlines, concurrency/leases, final outcome | Retrieval or model selection — those are Context Runtime's |
| Context Runtime | What should this node know, and which intelligence path? | Representation execution, retrieval routing, context assembly/compression, model & reasoning-effort selection, evidence thresholds, caching, answer verification, cost telemetry | Cross-node workflow orchestration, approvals, side effects, saga rollback, application discovery — those belong to Mission Runtime / Discovery |
| ReDevOps RAG | Find the evidence for a query. | Indexing, hybrid retrieval, reranking, graph-aware/multi-stage retrieval, thresholds, chunk/provenance contracts | Anything else — it is a capability Context Runtime may route to (alongside SQL, a property graph, an API), not a platform layer |
| agent-harness | How does one model/tool step run safely? | The reusable execution substrate under the capability plane: model/provider clients & gateway primitives, tool registry & invocation, approval mechanisms, sandbox execution, command/egress guardrails, secret materialization, generic agent-loop state, evaluator/test primitives | What to retrieve, the mission topology or the business goal — it provides primitives and decides none of them; coding-specific worktrees/merges belong to Sidekick |
| Shared contracts | What does every repository mean by a shared type? | Canonical schema identity & versioning, serialization/hashing rules, compatibility & evolution rules, visibility/tenancy/provenance types, neutral policy & proof-result schemas, capability-grant & deployment-manifest schemas, golden fixtures & cross-language conformance vectors — carried inside the public runtime (each with a CONTRACT_VERSION + inline fixtures), not a separate package | Any planning, retrieval or execution algorithm, or any product policy value — they define portable meaning, never enforcement |
| Sidekick | How does a human operate missions conversationally? | Accepting goals, generating manifest changes / mission proposals, explaining plans, monitoring, coordinating workers, surfacing failures, requesting approvals, proposing remediation, inspecting evidence | An independent control plane — every mutation goes through Mission Runtime |
| Projects | Where does durable project & deployment state live? | The control-plane resource model: Project Manifest, environments, tenant/deployment identity, desired vs observed state, mission history, discoveries, policy bundles, connected capabilities, learning state, approvals, audit ledger, CI/CD (see the Projects Control Plane) | — |
Orthogonal to the control/data-plane deployment split below, this is the persistence rule for every component above. One question decides where a thing lives: would losing it on restart be a bug, or just a recompute? A bug means durable, shared truth — it belongs in a store (the State plane, realized). A recompute means a contract, a decision or a rule — it stays behavior in the runtimes. The runtimes are stateless by preference and reach state only through the named contracts below, and every decision they make traces to evidence in a store.
rehydrate() recompiles the plan and fails closed unless it reproduces the sealed plan fingerprint and ContextEpochEventStore: in-memory/JSONL, embedded DuckDB or shared Postgres — event_backends.py); evidence rows in the Historical Evidence Plane (EvidenceStore) are content-addressed and re-verifiable. Hash-chained tamper-evidence of the kernel log itself is not in the open storeProjectManifest, environments, desired/observed, mission history, learning state, auditObservation store (valid_at · known_at · ingested_at, Postgres, leakage-safe as-of queries — observation_store.py). A mission’s WorldState and its fused beliefs are not a separate store: they are folded from the mission’s ObservationWritten events and recompute from the ledgerOutcomeStore: JSONL file or Postgres) and the policy-promotion log (PolicyRegistry store: JSONL or Postgres, so a promoted policy survives restart and is re-read by the next selection). The learner and any candidate policy recompute from the log; a promotion is persisted before it takes effect and only through a passed gate (policy_promotion.py). The kernel’s per-mission LearningStack promotions are still in-memoryDeploymentIdentity digestsContextView / render caches (materialized, rebuildable). A ContextView and its ContextEpoch are content-addressed pure functions of their handles and pins; the epoch id is recorded on the plan and re-derived on replay. Plan caching is per component: the kernel Mission Runtime keeps no plan cache (plans are recomputed, or replayed from the event log and checked against the sealed fingerprint), while the Context Runtime planner keeps one — an in-process SnapshotPlanCache keyed on normalized intent, pinned source versions, a tenant + permissions + sensitivity fingerprint and the constraint envelope, so a changed source version misses and re-plans; it is switched off under online learning and is not durable (context-runtime commit 67c6f1e)MissionEvent (runtime → ledger) · EvidenceArtifact / ContextView (Context → verification, materialized) · the data & context gateway (Context → retrieval) · CredentialGrant (a leased reference, never the secret) · ProjectManifest (Projects ↔ every plane) · DeploymentIdentity (running system → conformance). A runtime never reaches into a store except through one of these. As implemented in the open code: the runtime → ledger crossing is the kernel’s Event record appended to the mission EventStore (the content-addressed RuntimeEvent family lives in runtime-contracts); MissionEvent, WorldState, Outcome and LearningObservation name roles that are not yet one-to-one public classes.Three rules resolve the gray zones. State is split from its transitions — the durable row belongs to a store, the transition that produced it to the runtime, so a mission stays replayable and a learner model stays inspectable. Reward is data; policy is behavior — a LearningObservation is persisted, the policy that consumes it is recomputed, and the mutable state a policy scores is never itself the reward. Caches are materialized views — durable and shared, but always reconstructible from evidence and inputs; and config may be persisted as data, but its enforcement is always behavior.
ExecutionPlanimplemented A single public cross-runtime schema that Discovery, the Planner, Mission Runtime and Context Runtime all speak — one authoritative object in code (Python and Go, at field parity), carrying the six logical axes, the governance envelope, the planner's expectations and the compiled graph. Discovery and the Planner both build it through adapters; the mission compiler lowers it to a graph. Migrating every remaining call site to import it from the one module is ongoing; the schema itself is authoritative.
ExecutionPlan( plan_id, goal, discovery_context, representation_plan, # documents · SQL · property graph · temporal retrieval_plan, reasoning_plan, model_plan, topology_plan, # single-agent · coordinator-workers · … capability_plan, verification_plan, governance_plan, budget, deadline, evidence_requirements, expected_cost, expected_latency, expected_quality, fallback_plan, )
The lifecycle is one line:
DiscoveryProposal → ExecutionPlan → CompiledMissionGraph → MissionRun → Outcome
Existing types (GovernancePlan, CompiledMissionGraph, ExecutionTopology, the Context candidate plan, route results, capability plan) become nested types or compatibility wrappers of this one object.
These are the schemas that cross component boundaries. They matter more than any deployment diagram: as long as every repository speaks these exact contracts, no repository can invent an incompatible concept. Each is defined once, at Python/Go field parity, and versioned.
| Contract | What crosses the boundary | Between |
|---|---|---|
ProjectManifest | Desired project/deployment state — capabilities, policies, environments, connected data | Projects ↔ every plane |
WorldState | The observed model of the managed system | Discovery ↔ Mission |
StateDelta | A change in world state that may deserve action | → Discovery |
DiscoveryProposal | A scored, ranked opportunity/risk with a suggested mission | Discovery → Planner |
ExecutionPlan | The one complete plan (six axes + governance + budgets + fallbacks) | Planner → Mission |
CompiledMissionGraph | The lowered, executable graph | Mission (compile→run) |
MissionEvent | An event-sourced state transition of a running mission — append-only, content-addressed | Mission ledger |
EvidenceArtifact | A cited unit of assembled context/evidence | Context → verification |
VerificationResult | The pass/fail (and grounds) of a verification stage | Context/Mission |
Outcome | The verified result of a mission + its effect on world state | Mission → Learning |
LearningObservation | The reward/observation that updates a policy | Outcome → Learning |
Capability | The contract for any model/tool/agent/retriever/human — id · version · schemas · side_effects · permissions · cost/latency/quality · approval · verification · provenance | Capability plane |
SecurityDecision · AuthorityContext | A deny-wins security verdict, and a delegation chain that only ever narrows (child ⊆ parent by construction; every consequential side effect resolves to one chain_ref) | Cross-cutting control plane |
RuntimeSecurityEvent | The runtime's own security record, emitted at the capability boundary — hashes not payloads, not agent-reported — folded into a trajectory and correlated into a governance disposition | Capability boundary → Governance |
CredentialGrant | A leased just-in-time credential reference — scope · authority · material hash — never the secret, so no plan/context/fingerprint ever carries a token | Credential broker ↔ capability |
ExecutionEnvelope · ExecutionReceipt | The signed authorization for one contained side effect — bound to mission · plan · authority · credential references · idempotency · expiry, with a network/filesystem/resource ExecutionConstraint. Its identity is the hash of its own canonical form, so a tampered field is simply a different envelope no authority issued; the envelope-bound receipt is what a replaceable executor cannot forge | Approved capability → execution membrane |
Freezing and round-tripping these across repositories is the platform's first implementation milestone — see Phase 0 on the roadmap →.
These contracts are defined and versioned inside the public runtime itself — each carries a CONTRACT_VERSION and inline golden fixtures every implementation must round-trip; the definitions hold no planning, retrieval or execution logic and no product policy values, so no runtime invents a competing copy of a shared type. Conformance is a ladder, not a checkbox: a schema with no live adopter is SPECIFIED; an adapter that round-trips the fixtures is CONFORMANT; only a deployed path that produces and verifies the artifacts is DEPLOYED_CONFORMANT. Reproducing a golden hash proves translation, not that the production path adopted the contract — the honest distinction the whole page is labelled against.
One planned extension of this contract discipline is on the roadmap. Proven contracts — a PROVEN rung above SPECIFIED, where a contract's laws are machine-checked in Lean 4: that merge() is idempotent, commutative and associative (so hierarchical/parallel integration is order-independent), and that governed reconciliation is sound and complete. The golden fixtures are then generated from the proven spec, so a DEPLOYED_CONFORMANT implementation of a PROVEN contract is the strongest claim the platform can make — proven, then tested against the proof. It is deferred until a live adopter validates it — the deployment-proof rule, applied to the roadmap.
The ten whitepapers are one lineage, not ten parallel specifications. Each contributed a layer of today's model; v10 is the current paper — the reference-first harness layer, v9 is the portable Kotlin/Spark implementation, and v1–v8 are the conceptual foundations they reference.
| Papers | Canonical contribution | Belongs to |
|---|---|---|
| v1–v3 | Intent over hardcoded pipelines; candidate generation; cost/quality/latency planning; retrieval & model routing; verification; learning from outcomes | Context Runtime foundation |
| v4–v6 | Mission as the unit of execution; event-sourced state; execution graph; simulation; approvals; replay; world state; saga/compensation; policy & capability boundaries | Mission Runtime (governed execution) |
| v7 | Documents/SQL/property-graphs/temporal as first-class representations; representation selection before retrieval; hybrid plans; one explainable plan | Execution Planner + Context Runtime boundary |
| v8 | Discovery Runtime; state deltas; sparse capability activation; evidence carry-forward; proactivity budgets; execution-topology selection; safe self-learning; the complete ExecutionPlan | System-level paper — spans all three runtimes + the Learning plane |
| v9 | Portable Kotlin/JVM implementation of the three runtimes + the Execution Planner + ReDevOps RAG; Apache Spark as a distributed execution backend + a smaller Databricks adapter subset. Same contracts and naming — an implementation/portability paper, not a new layer. | Implementation · JVM · Spark · Databricks |
| v10 current | Reference-first context — the governed harness: models observe only ContextViews materialized by the runtime; ArtifactHandle / ContextView / DereferenceEvent within the normalized RuntimeEvent family; model-callable graph APIs; append-only sessions; compaction as governed merge(); monitor-first enforcement with a clean-decision gate. Amendments carry the per-runtime specs (capability descriptors, prediction/residual, Mission programs, object store, acceptance chains). Extension — Evaluation Runtime: the same substrate applied to running AI benchmarks (Dataset → ContextView → Run → Verify → Publish → Finding). See v10 and the security doc. | The agent-harness layer · spans all runtimes |
The runtime intelligence is broad; the production platform around it is deliberately staged. Each plane is labelled public (shipped & documented), preview (implemented, hardening) or planned.
| Plane | What it provides | Status |
|---|---|---|
| Control plane | Project Manifest & registry, tenant/environment lifecycle, deployment topology, config versioning, desired/observed reconciliation, signed artifacts, promotion, backup/restore/DR | preview |
| Identity & access | OIDC/SAML SSO, service & workload identities, RBAC/ABAC, scoped capability grants, approval authority, break-glass, tenant isolation, full access audit — deny by default. The scoped-grant plane (subject × resource, row scope, column mask, encrypted-at-rest fail-closed grant store) is open: permissions.md. Signed, input-bound approval tokens for HTTP operators ship in the kernel (APPROVAL_TOKENS.md). SSO/federation stays enterprise. | scoped grants public SSO preview |
| Policy plane | One service for capability eligibility, data residency, provider/model restrictions, tool permissions, approval rules, budget limits, retention, PII, autonomy limits — policy prunes plans before learning or model calls | preview |
| Model gateway | Provider abstraction, quotas, retries/fallbacks, token & cost accounting, logging policy, session contracts, caching, regional routing, structured-output validation, allowlists, DLP | preview |
| Data & context gateway | Connector plane (files, object stores, SQL, warehouses, property graphs, search, SaaS, event streams, APIs, humans), each exposing schema · permissions · freshness · provenance · cost · latency · classification | preview |
| External & professional intelligence | The realized external-evidence layer behind the gateway: a decision asks for a capability (person/company enrichment, sanctions & beneficial-ownership risk, web/search/social market intelligence, IP/domain/malware threat intel, vulnerability exploitability, legal research/drafting, email delivery) — never a provider. A value gate decides whether external evidence can change the decision and is worth its cost · latency · privacy · licence before acquiring; the result is a governed evidence artifact carrying provenance · cost · freshness · licence, and a verified-outcome ledger later scores whether buying it helped. The open baseline (GLEIF · OpenSanctions · OpenCorporates) runs with no keys, and open adapters for OpenFIGI, SEC EDGAR, Companies House and Open Ownership have since landed; paid, legal and email-delivery providers are Bring-Your-Own, and the managed paid providers live in a private metered gateway, not the open bridge. Contracts are public in runtime-contracts; adapters + gate in agentic-os. | preview |
| Capability registry | One contract for every model, tool, agent, retriever, strategy and human: id · version · schemas · side_effects · permissions · cost/latency/quality models · approval_required · verification · provenance | preview |
| Observability & evaluation | Traces from DiscoveryProposal to Outcome; cost/latency per mission & node; context provenance; plan alternatives; policy decisions; verification failures; learning rewards; business outcomes. v0.3.x adds Mission-native OpenTelemetry correlation: the Mission is the root trace and a deployment substrate (Argo Workflows, raw K8s, Terraform, cloud APIs, edge) nests underneath the causing node — one causal tree from "why did we decide to deploy?" down to "which pod/artifact took 4 seconds?". Trace ids are content-addressed (replay-stable); OTel is the export layer, not the source of truth; substrate adapters (Argo behind a beta guard) are optional. | preview |
| Continuous compliance & AI security | Prompt-injection detection, tool-abuse prevention, MCP trust/permission checks, supply-chain provenance, model/prompt lineage, data-leakage detection, policy/infra drift, mission-based remediation — a cross-cutting service, not one demo. v0.3.0 canonicalizes this into one cross-runtime contract (Python/Go byte-identical): the epistemic layer (evidence may influence belief, never grant itself authority) enforces prompt-injection & poisoned-tool-metadata screening; CapabilityDescriptor.admit() is digest-pin/provenance supply-chain admission; redact() is the reusable hashes-not-payloads rule; JIT CredentialGrants keep secrets out of context; and a Containment state machine acts on the correlated disposition. Opt-in, but fail-closed once a capability declares isolation/authority/a pin. Under the hood → | v0.3.0 |
| Governance & trajectory | Cross-agent trajectory governance over one normalized event history: sequence/correlation rules that catch multi-agent patterns no per-action check can see — turf-war escalation and fragmented exfiltration in the trajectory foundation, extended in v0.2.x with cross-series (evidence-aware) rules (correlating an evidence-change series against an action series → REQUIRE_REVIEW) and OBSERVE/ENFORCE enforcement maturity (the same rule shadowed then promoted without changing detection); the epistemic screening half landed in v0.3.0 (canonical adversarial validators in runtime-contracts), while conformity collapse, resource flooding and collusion arrive as the population engine and the authority-weighting registry land next (planned — neither is in the public repositories yet; nor are the trajectory rules and DecisionGate named here, so those are not independently checkable from the open code); a fail-closed DecisionGate; a per-surface coverage matrix (a real DENY only where a synchronous pre-action gate exists, else NO_OVERRIDE); findings routed to Mission Runtime. Under the hood → | v0.3.x |
| Sandboxed execution | Per-mission containment behind a signed ExecutionEnvelope (mission · plan · authority · credential-refs · idempotency · expiry) and a network/filesystem/resource ExecutionConstraint: credential-blind tools (the agent holds references, never secrets), side-effect recording, and an envelope-bound ExecutionReceipt. The contracts are public and an open, rootless reference membrane ships (env-scrubbed subprocess + resource limits, trusted-host scope); the open membrane enforces filesystem containment, resource ceilings and process isolation but not network-egress control, so an isolated-or-stronger profile fails closed there (execution_backend.py); the hardened tier — OS namespaces / microVM / remote-attested execution — stays enterprise and derives from the same ExecutionConstraint. Under the hood → | contracts public membrane preview |
| Multi-tenancy | Tenant-scoped state & encryption, isolated indexes, quota/budget/key isolation, tenant audit export, retention/deletion, per-tenant policies, noisy-neighbour controls | preview |
| Metering & commercial ops | Usage accounting, subscription/invoice integration, cost allocation, tenant budgets, overage, SLA reporting, support bundles, customer export/deletion | preview |
| SDK & compatibility | The Mission SDK — declarative mission/capability authoring + the rdo mission DevOps CLI, the developer boundary above alpha — over the Python & Go language SDKs, a gRPC service + a canonical contract IDL (one .proto → typed .NET/C# and any-language clients; Entra ID (Azure AD) auth; remote .NET-hosted capability operators), REST/OpenAPI, event/webhook contracts, OpenTelemetry (→ Azure Monitor), MCP adapter, LangChain/LangGraph & CrewAI/Strands adapters, OpenAI-compatible gateway, Helm chart, Terraform/OpenTofu module. The Go runtime's service + gRPC dependencies are isolated in a separate module so the runtime core stays zero-dependency. | preview |
Every plane has a defined route to Public — and on the v0.3.x line most planes are now there, validated by a live Apps Demo and/or a benchmark. Two of the four formerly-planned enterprise planes now have a validated public tier: identity & access (scoped grants deny-by-default, via the Permissions demo + the identity benchmark) and sandboxed execution (the open, rootless reference membrane, via the Intrinsic Security demo). Their deeper enterprise tiers — SSO/federation and the hardened OS-namespace / microVM / remote sandbox — and the two remaining planes, multi-tenancy and metering, stay enterprise-only and preview until pilot deployments validate them. See the platform roadmap →.
The message to an existing application: keep your framework. Move planning, context, governance, discovery and learning into the runtime. Proven, not claimed — the same runtime built and measured around eight frameworks and clouds (NeMo · PydanticAI · LlamaIndex · CrewAI · Azure · Google · AWS · DigitalOcean): see the reference implementations.
Status, checked against the code: the contract-and-scaffolding half has landed in agentic-os (v0.2.4 and later); the adapters and the live-cluster proof have not. landed the vendor-neutral provider-capability/v1 surface (capability kinds, CapabilityResult, ProviderIdentity, ExecutionTargetStats, DeploymentIdentity — provider.py), deterministic hardware-aware target selection over a pinned statistics snapshot (target_selection.py), offline deployment conformance up to CONFORMANT (deployment_conformance.py), the neutral benchmark-lane structure (provider_benchmark.py) and the nvidia-nim / nemo-retriever / nvidia-kubernetes / amd-kubernetes / amd-instinct Helm profiles (profiles). not yet dedicated NIM / NeMo Retriever / NeMo Guardrails / OpenShell adapters, a live-cluster DEPLOYED_CONFORMANT record, and the cross-provider benchmark runs — the NVIDIA benchmark profiles report UNEXERCISED, never green, until GPU hardware supplies inputs. The one-providers:-flip claim below is therefore still to be earned.
The next major step is making GPU-vendor stacks — NVIDIA and AMD — first-class capability backends and deployment targets, without letting any vendor concept become canonical runtime semantics. ReDevOps stays the sole planning and execution authority; accelerator services are accelerated capabilities behind one vendor-neutral contract surface — ModelCapability, EmbeddingCapability, RerankCapability, GuardrailCapability, SandboxCapability, each returning a common CapabilityResult that pins provider, service, model and deployment identity as ordinary evidence.
The two vendors are two thin profile families over that one surface, not parallel stacks. NVIDIA is adapter-heavy — supported wrappers for NIM inference, NeMo Retriever extract/embed/rerank, NeMo Guardrails (observe-only; runtime policy still decides) and OpenShell sandbox — plus nvidia-nim / nemo-retriever / nvidia-kubernetes Helm profiles (the latter three are in the chart; the supported wrappers are not yet). AMD is deliberately profile-heavy: its ROCm serving (vLLM/SGLang) is OpenAI-compatible, so the existing model and retrieval adapters serve it by pointing at an endpoint — the work is amd-kubernetes / amd-instinct profiles on amd.com/gpu (scaffolded in the reference-system Helm chart, with a ROCm model template) and Instinct hardware statistics — where a single MI300X/MI355X (192–288 GB HBM) legitimately changes placement. That AMD drops in as profiles rather than new contracts is the proof the surface is vendor-neutral — a second implementer, the same conformance argument as the multi-language runtime.
Around that surface sit three shared, build-once pieces: hardware-aware planning (physical facts — accelerator kind, HBM, latency, cost — as pinned, explainable ExecutionTargetStats, never an application hardware branch); deployment conformance (a live-cluster DeploymentIdentity proving the running chart, values, images and adapters match the approved artifacts — the DEPLOYED_CONFORMANT rung applied to Helm); and a neutral benchmark lane that runs the identical Mission across providers with complete evidence. The one claim it must earn: a single Mission runs unchanged on NVIDIA, AMD and non-accelerated profiles, with one providers: flip and equal canonical outputs. Scope is deliberately bounded — no ROCm/HIP kernels, no Ryzen AI, no vendor retrieval store or orchestration layer; if a fact lives below the served endpoint, it is the vendor's to own, not ours to model.
"Drop-in runtime" means one thing at three scales. The same runtimes and contracts run in all three — no rewrite between them, only more of the control/data plane split out as you grow. This is deliberate, so a first deployment never has to assume the full enterprise topology.
| Mode | Intended user | What runs |
|---|---|---|
| Embedded library | An individual application or a local developer | The runtimes as in-process libraries (Python/Go), no standing services — the fastest path to a golden path. |
| Single-node platform | A pilot, a department, a private deployment | The full control + data plane on one node (Docker Compose), Sidekick, one tenant — what the reference stack runs. |
| Distributed control / data plane | Enterprise, multi-tenant | Separated and independently scaled control and data planes (Helm/Kubernetes), hard tenant isolation, HA. |
Compatibility surface, the same in every mode: Python & Go SDKs, a gRPC service + contract IDL for typed .NET/C# clients (with Entra ID / Azure AD auth and remote .NET-hosted operators), REST/OpenAPI, OpenTelemetry (→ Azure Monitor), an MCP adapter, LangGraph/LangChain and CrewAI/Strands adapters, an OpenAI-compatible model gateway, Helm and Docker Compose packages, and Terraform/OpenTofu modules — plus your existing identity and secrets providers. The Go runtime now runs as a standing gRPC/HTTP service (not only as an in-process library); its service dependencies are isolated so the core remains zero-dependency.
Every element on this page is one of five availability states. This axis is separate from maturity (public/preview/planned): a plane can be hardening and enterprise-only. It is called out because a claim is only honest if a reader can tell whether the code is in the public repositories or behind an enterprise/preview boundary.
Two versions diverge from one protocol. The open runtime — the canonical contracts, protocol shapes, and reference runtimes — is AGPL and fully inspectable: runtime-contracts · agentic-os · context-runtime · redevops-conformance. The Enterprise Edition is the private production enforcement, integrations, and hardened runtimes behind those same seams. There is no separate "enterprise architecture" — one open protocol, stronger private enforcement.
| Availability | What it means | Examples |
|---|---|---|
| Source-available · merged oss | In the public repositories, on the default branch | Context Runtime (contextos · context-runtime-go), the public control-plane OSS (runtime interfaces + Mission/Context kernels), ReDevOps RAG, the canonical ExecutionPlan schema, the versioned contract schemas + golden fixtures carried in the public runtime, the intent side of the Discovery Runtime (discovery-runtime: draft · fuse · seal, incremental, lesson lifecycle), the Mission SDK (mission-sdk), and the Go Mission kernel |
| Source-available · experimental oss-exp | Public, but on a feature branch / behind a build flag | Native Go multimodal (ColPali/ONNX behind a build tag), in-flight retrieval/router work |
| Hosted / private preview preview | Runs in the hosted demos, not yet a released package | demo.redevops.io · chat.redevops.io · quantify.club |
| Enterprise-only ent | Private reference implementations; not promoted to open core | The Discovery Runtime’s signal engine (detectors, correlation, ranking, proactivity budgets), the self-learning insurance loop, execution-topology & the v8 efficiency primitives, Context Fabric, the enterprise policy plane, analytical/OLAP stores — the identity & access, sandboxed execution, multi-tenancy & metering planes (implemented Python + Go; private until pilot-validated) — and the runtime plugins: security enforcement, the telemetry/OpenTelemetry bridge, and deployment-substrate adapters (Argo), all injected into the open runtime-contracts seams |
| Planned planned | Designed, not built | Ray and Spark execution backends and the named analytical / OLAP adapter classes — interfaces exist; the backends are roadmap. A Dagster operator client and a compile-plan-to-one-Dagster-job path are implemented but only unit-tested against a stubbed transport (partial; see the roadmap) |
| You may still see | Canonical term |
|---|---|
| Agentic Runtime | AI Runtime Stack (a.k.a. rAIls / AI Decision Runtime) |
| Four runtimes | Three runtimes + the Execution Planner |
| Sidekick shell | Sidekick Mission Supervisor |
| Projects cockpit | Projects Control Plane |
| ReDevOps RAG layer | Reference retrieval capability (in the capability plane) |
| Decision Flow Planner | Execution Planner |
| ContextOS | Context Runtime |
| Learning Runtime | Learning plane (unless independently deployed) |
| Apps | Domain systems / capability providers |
| Harness / agent primitives / model gateway | agent-harness (reusable execution substrate) |
| Wire schemas / golden fixtures / contract versions | the public runtime (versioned contracts + conformance fixtures, carried inline) |
The platform taxonomy stays small on purpose: there is no Project Runtime, no top-level Story Runtime, no separate per-domain runtimes, and no separate "decision runtime" beside the planner. The one component name that is canonical below the runtimes — agent-harness (how a step runs) — exists precisely so reusable behavior never gets trapped inside a reference application. Shared contract meaning is carried the same way, but by the public runtime kernel itself — versioned schemas + golden fixtures — so no reference application quietly becomes the owner of a runtime primitive.
One consumer of agent-harness and the public runtime contracts is ReDevOps QA preview, a pre-release developer tool (public repository, no tagged release) that runs test engines (Playwright, Selenium, Robot Framework, Appium) under one contract and keeps their evidence.