← redevops.io
Architecture · the canonical spec · redevops.io

Platform architecture

Three runtimes, one Execution Planner, one control plane, one capability plane.
This page is the single reference the whitepapers and under-the-hood decks defer to. Where an older page and this page disagree, this page wins.

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.

The canonical stack

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.

Projects + Sidekick — control plane
manifests · tenants · environments · approvals · audit · Sidekick Mission Supervisor · APIs · SDKs
↓
Discovery Runtime
observe · detect · correlate · rank · propose  —  what deserves attention?
↓
Execution Planner
representations · retrieval · reasoning · models · topology · budgets · verification · governance · fallbacks  —  what complete plan should run?
↓
Mission Runtime
graph · simulate · gate · execute · compensate · verify · replay · audit  —  how is the plan executed and governed?
↓
Context Runtime
retrieve · assemble · represent · route · reason · verify · cache · learn  —  what intelligence does each node receive?
↓
Capability plane
models · RAG · SQL · graphs · APIs · tools · agents · humans  —  each model/tool step executed through the agent-harness substrate (clients · tools · sandbox · approvals · guardrails · eval)
↓
Observed outcome → Learning + world-state update
every outcome updates policy and the world model
Cross-cutting planes: Identity · Policy · Governance · Security · Observability · Evaluation · State · Artifact lineage · Metering · Compliance — spanning every layer above.

The developer boundary — Mission SDK + Mission DevOps alpha

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:

Who owns what

One responsibility table, so no two pages describe the same behaviour twice.

ComponentAnswersOwnsDoes not own
Discovery RuntimeWhich changes deserve a mission?World-state observation, StateDelta, detectors, correlation/suppression, hypotheses, opportunity/risk ranking, proactivity budgets, mission proposals, safe policy learningExecution — it proposes missions, it never acts
Execution PlannerWhat complete plan should run?Representation selection, retrieval/reasoning/model plan, execution topology, budgets, verification & governance plan, fallbacks — one explainable ExecutionPlanPersistent lifecycle/APIs of its own — it is a planner, not a runtime
Mission RuntimeHow 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 outcomeRetrieval or model selection — those are Context Runtime's
Context RuntimeWhat 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 telemetryCross-node workflow orchestration, approvals, side effects, saga rollback, application discovery — those belong to Mission Runtime / Discovery
ReDevOps RAGFind the evidence for a query.Indexing, hybrid retrieval, reranking, graph-aware/multi-stage retrieval, thresholds, chunk/provenance contractsAnything else — it is a capability Context Runtime may route to (alongside SQL, a property graph, an API), not a platform layer
agent-harnessHow 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 primitivesWhat 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 contractsWhat 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 packageAny planning, retrieval or execution algorithm, or any product policy value — they define portable meaning, never enforcement
SidekickHow 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 evidenceAn independent control plane — every mutation goes through Mission Runtime
ProjectsWhere 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)—

The state boundary — what persists, what recomputes

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.

Behavior — the runtimes

recompute if lost
  • Shared contracts — the type definitions; instances persist, the schemas do not
  • Discovery · Execution Planner · Mission · Context — every plan, route and verdict, deterministic and replayable; in the kernel Mission Runtime rehydrate() recompiles the plan and fails closed unless it reproduces the sealed plan fingerprint and ContextEpoch
  • Governance, policy & security enforcement — reads policy, emits events; holds no durable verdict of its own. The one deliberate exception is in-process state: the approval-token replay guard is per-process, so multi-replica operators need a shared store behind it (APPROVAL_TOKENS.md)
  • Capability plane & agent-harness — how a model/tool step runs
  • EXPLAIN — generated from the ledger, never stored as opinion

Truth — the stores (State plane, realized)

bug if lost
  • Mission evidence & event ledger (kernel Mission Runtime) — the append-only mission event log (kernel EventStore: 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 store
  • Projects control-plane state — ProjectManifest, environments, desired/observed, mission history, learning state, audit
  • World model (kernel Mission Runtime + observation plane) — the durable record is the bi-temporal Observation 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 ledger
  • Retrieval corpora & indexes — the ReDevOps RAG store, connector data + provenance
  • Outcomes & learning (agentic-os apps/learning plane; not the Context Runtime library) — the outcome log (OutcomeStore: 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-memory
  • Secrets & provenance at rest (open floor: runtime-contracts + agentic-os; hardened tiers enterprise) — credential material behind the broker, never in a plan, context or ledger. The open floor is env/file stores plus a platform-secrets bootstrap (generated once, stored in a 0600 file, OS keyring or Vault, never printed — SECRETS.md); tenant-scoped encryption is enterprise. Also conformance / DeploymentIdentity digests
  • Artifacts & caches (ContextView/ContextEpoch: kernel; plan cache: Context Runtime) — object store, ContextView / 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)
The seams — the only crossings, each a canonical contract: 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.

The one canonical ExecutionPlan

implemented 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.

The canonical public contracts

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.

ContractWhat crosses the boundaryBetween
ProjectManifestDesired project/deployment state — capabilities, policies, environments, connected dataProjects ↔ every plane
WorldStateThe observed model of the managed systemDiscovery ↔ Mission
StateDeltaA change in world state that may deserve action→ Discovery
DiscoveryProposalA scored, ranked opportunity/risk with a suggested missionDiscovery → Planner
ExecutionPlanThe one complete plan (six axes + governance + budgets + fallbacks)Planner → Mission
CompiledMissionGraphThe lowered, executable graphMission (compile→run)
MissionEventAn event-sourced state transition of a running mission — append-only, content-addressedMission ledger
EvidenceArtifactA cited unit of assembled context/evidenceContext → verification
VerificationResultThe pass/fail (and grounds) of a verification stageContext/Mission
OutcomeThe verified result of a mission + its effect on world stateMission → Learning
LearningObservationThe reward/observation that updates a policyOutcome → Learning
CapabilityThe contract for any model/tool/agent/retriever/human — id · version · schemas · side_effects · permissions · cost/latency/quality · approval · verification · provenanceCapability plane
SecurityDecision · AuthorityContextA 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
RuntimeSecurityEventThe 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 dispositionCapability boundary → Governance
CredentialGrantA leased just-in-time credential reference — scope · authority · material hash — never the secret, so no plan/context/fingerprint ever carries a tokenCredential broker ↔ capability
ExecutionEnvelope · ExecutionReceiptThe 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 forgeApproved 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 whitepapers, as an evolutionary record

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.

PapersCanonical contributionBelongs to
v1–v3Intent over hardcoded pipelines; candidate generation; cost/quality/latency planning; retrieval & model routing; verification; learning from outcomesContext Runtime foundation
v4–v6Mission as the unit of execution; event-sourced state; execution graph; simulation; approvals; replay; world state; saga/compensation; policy & capability boundariesMission Runtime (governed execution)
v7Documents/SQL/property-graphs/temporal as first-class representations; representation selection before retrieval; hybrid plans; one explainable planExecution Planner + Context Runtime boundary
v8Discovery Runtime; state deltas; sparse capability activation; evidence carry-forward; proactivity budgets; execution-topology selection; safe self-learning; the complete ExecutionPlanSystem-level paper — spans all three runtimes + the Learning plane
v9Portable 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 currentReference-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 production platform — what ships, what's coming

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.

PlaneWhat it providesStatus
Control planeProject Manifest & registry, tenant/environment lifecycle, deployment topology, config versioning, desired/observed reconciliation, signed artifacts, promotion, backup/restore/DRpreview
Identity & accessOIDC/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 planeOne 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 callspreview
Model gatewayProvider abstraction, quotas, retries/fallbacks, token & cost accounting, logging policy, session contracts, caching, regional routing, structured-output validation, allowlists, DLPpreview
Data & context gatewayConnector plane (files, object stores, SQL, warehouses, property graphs, search, SaaS, event streams, APIs, humans), each exposing schema · permissions · freshness · provenance · cost · latency · classificationpreview
External & professional intelligenceThe 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 registryOne contract for every model, tool, agent, retriever, strategy and human: id · version · schemas · side_effects · permissions · cost/latency/quality models · approval_required · verification · provenancepreview
Observability & evaluationTraces 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 securityPrompt-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 & trajectoryCross-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 executionPer-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-tenancyTenant-scoped state & encryption, isolated indexes, quota/budget/key isolation, tenant audit export, retention/deletion, per-tenant policies, noisy-neighbour controlspreview
Metering & commercial opsUsage accounting, subscription/invoice integration, cost allocation, tenant budgets, overage, SLA reporting, support bundles, customer export/deletionpreview
SDK & compatibilityThe 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.

Next release — accelerated capability backends in progress

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.

Deployment modes

"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.

ModeIntended userWhat runs
Embedded libraryAn individual application or a local developerThe runtimes as in-process libraries (Python/Go), no standing services — the fastest path to a golden path.
Single-node platformA pilot, a department, a private deploymentThe full control + data plane on one node (Docker Compose), Sidekick, one tenant — what the reference stack runs.
Distributed control / data planeEnterprise, multi-tenantSeparated 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.

Source-available vs. enterprise — what actually ships where

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.

AvailabilityWhat it meansExamples
Source-available · merged ossIn the public repositories, on the default branchContext 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-expPublic, but on a feature branch / behind a build flagNative Go multimodal (ColPali/ONNX behind a build tag), in-flight retrieval/router work
Hosted / private preview previewRuns in the hosted demos, not yet a released packagedemo.redevops.io · chat.redevops.io · quantify.club
Enterprise-only entPrivate reference implementations; not promoted to open coreThe 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 plannedDesigned, not builtRay 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)

Naming — the canonical terms

You may still seeCanonical term
Agentic RuntimeAI Runtime Stack (a.k.a. rAIls / AI Decision Runtime)
Four runtimesThree runtimes + the Execution Planner
Sidekick shellSidekick Mission Supervisor
Projects cockpitProjects Control Plane
ReDevOps RAG layerReference retrieval capability (in the capability plane)
Decision Flow PlannerExecution Planner
ContextOSContext Runtime
Learning RuntimeLearning plane (unless independently deployed)
AppsDomain systems / capability providers
Harness / agent primitives / model gatewayagent-harness (reusable execution substrate)
Wire schemas / golden fixtures / contract versionsthe 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.

redevops.io — Platform architecture · the canonical specification. Claims are labelled public / preview / planned. © 2026 redevops.io