← redevops.io
Draft · scheduled for later delivery · redevops.io

Context Runtime

Mission DevOps & the Sidekick-driven Operating System
Where this fits. v4–v6 introduce governed mission execution — the mission as the unit of execution, event-sourced state, the execution graph, simulation, approvals, replay and saga. The current system-level reference is Whitepaper v8; the canonical model is the Platform Architecture spec — where an older description here disagrees with the spec, the spec wins. What v6 calls the “shell of the Agentic Runtime” is today the Sidekick Mission Supervisor over the three runtimes.
The operating system around the v5 mission kernel: author → verify → deploy → run → observe — every mission something you write, test, ship and govern as one engineering workflow, all from Projects, all driven by Sidekick.

This is a draft. It captures work scheduled after v5 and not yet delivered. v5 is the shipped baseline — the mission kernel (event-sourced, evidence / verification / policy / world-belief / saga), all 15 app operators exposed over /capabilities + /invoke, the Projects / Mission-Plane cockpit, and two cross-app missions over the real operators (Revenue Rescue and Onboarding) with money/consent gates and saga rollback. Everything below is the plan for the DevOps operating system that wraps that kernel; treat phase claims as intent, not as completed guarantees.

Executive summary

Software teams already have DevOps for applications. Agentic systems require Mission DevOps — where the unit under test, deployment and governance is the mission itself, not the application. That is what v6 builds.

v5 delivered a runtime that executes business objectives: missions that plan, verify, gate on evidence, and unwind their committed effects when they fail. But a runtime is not yet a way of working. Authoring a mission, testing it before it touches production, shipping it to real infrastructure, running it across the fleet, and watching it in flight were still separate, manual acts. v6 is the operating system around the v5 kernel — the loops and stacks that turn missions into something you engineer end to end.

The through-line is a single idea: Projects is the mission DevOps control plane, and Sidekick is its CLI and deployment arm. The cockpit becomes to missions what ArgoCD and GitHub Actions are to code — author, simulate, verify, replay, deploy, run and govern from one surface. Sidekick drives the whole cycle, and — the move that makes it a DevOps system rather than a dashboard — it drives Terraform and Ansible, so a deployment is itself a governed mission.

The unit of delivery is no longer a release. It is a mission — authored, verified, deployed and observed as one governed workflow, driven by Sidekick.

From v5 to v6

v5 shipped the kernel and its operators: the P0–P11 mission runtime, event-sourced, where a reject now unwinds committed effects through the saga; all 15 apps as Mission Runtime operators speaking one HTTP capability contract over their real cores; the Mission Plane cockpit (Projects) as an MVP; and the two live cross-app missions with their gates and rollback. v6 adds nothing to the kernel's semantics — it adds the engineering loops around it: a Mission SDK to author missions and capabilities as code, a Mission CI stage that gates promotion, a Terraform + Ansible CD stack that ships as a governed mission, a SkyPilot-backed multi-cloud placement optimizer that learns cost/availability per workload, observability and monitoring exports, the Context Runtime compiler and RAG representation adapters, and Sidekick's evolution into the full Mission Supervisor. v5 is the runtime — now including its Reasoning Plane, where reasoning strategy is optimized per mission class; v6 is the operating system.

Projects is the mission DevOps control plane

The Mission Plane cockpit already treats missions the way a CI/CD system treats code — the v5 assets are a pipeline, they simply were not named as one. v6 makes the mapping explicit and closes the loop. A pipeline definition is a mission template plus capability manifests authored through the Mission SDK; the runtime target is the 15 app operators; the test-before-ship stage is Mission CI; the ship stage is Terraform + Ansible driven by Sidekick; observability is the EXPLAIN trace, timeline, world/belief and evidence the runtime already emits; and the control-plane UI is the cockpit itself.

DevOps concept        Mission-world equivalent                       v5 status
─────────────────     ─────────────────────────────────────────     ──────────────
Pipeline definition   mission template + capability manifests (SDK)  templates exist
Runtime target        the 15 app operators                           ✅ done
CI (test before ship) Mission CI: simulate→verify→replay→regression  primitives exist
CD (ship)             Terraform + Ansible, Sidekick-driven           Ansible exists
Observability         EXPLAIN · timeline · world/belief · evidence   ✅ data
Control-plane UI       the cockpit (Projects)                        ✅ MVP

Three loops run over that mapping, all surfaced in Projects and all driven by Sidekick. Author & register declares missions and capabilities as code and stands up a live operator registry — the cockpit discovers /capabilities from the 15 operators, with base URLs resolved from modules.yaml; this is the single wire that lets the cockpit run real cross-app missions. Mission CI is the pre-production loop — per mission: simulate the projection, policy-prune, verify against evidence and assertions, replay from the event log, and regress against golden missions; promotion gates on it. Run & govern is production — cross-app workflows over the operators, with approvals, budget meters and saga rollback.

A deliberate scope note: v6 does not add a code build/test pipeline. The only "CI" is Mission CI — verification of missions — and the only "CD" is Terraform + Ansible. Application and core code CI stays out of scope.

Deployment is a governed mission

The key move of v6 is to refuse to bolt CD on beside the runtime. Deployment runs through the runtime. An `infra` operator exposes capabilities that wrap Terraform and Ansible, so a deploy becomes an ordinary mission — gated, verified, evidence-backed, and rolled back by the same saga that unwinds any other mission.

infra.plan             → terraform plan       (read-only; the diff becomes evidence)
infra.provision        → terraform apply       [gate: approval]  side_effecting,
                                                undo = infra.destroy_delta
infra.configure        → ansible-playbook       side_effecting,
                                                undo = infra.rollback_release
infra.verify           → /health + /capabilities + smoke   (verification plane)
infra.destroy_delta    → terraform apply -destroy of the just-added delta  (saga comp.)
infra.rollback_release → ansible redeploy previous image tag               (saga comp.)

deploy_app template:
  image and dependency vulnerability scan   (planned, not implemented today)
        ↓
  infra.plan  →  [approval gate]  →  infra.provision  →  infra.configure  →  infra.verify
        ↓  verification failure OR rejected gate
  saga unwinds: destroy_delta + rollback_release
scan (planned)not implementedinfra.planterraform planapproval gatehuman sign-offinfra.provisionterraform applyinfra.configureansibleinfra.verifyhealth + smokesaga unwindsdestroy_delta + rollback_releaseverify fails / gate rejected
Deployment runs through the runtime: the deploy_app template is a gated, evidence-backed mission. A verification failure or a rejected gate unwinds via the saga — it destroys the just-added delta and redeploys the prior image tag.

The deploy_app mission template reads exactly like the flow above: an image and dependency vulnerability scan is planned as the first step (it is not implemented today), infra.plan produces the diff as evidence, an approval gate stands between plan and apply, then provision, configure and verify run in order. A verification failure or a rejected gate unwinds via the saga — v5 already compensates on reject — so a failed deploy destroys the delta it just added and redeploys the prior image tag rather than leaving a half-applied stack.

Three consequences follow. First, a deploy gate you already own: the Mission-CI checks, so a failing mission does not ship, with human approval before apply. An image and dependency vulnerability scan is a planned second gate; it is not implemented today, and no deploy or mission is gated on CVE results. Second, deterministic, replayable deploys with a recorded history — the event log is the deploy history and EXPLAIN is the change record. Third, rollback for free — a failed deploy compensates instead of stranding the fleet.

Invariant. infra.provision is the highest-consequence capability in the fleet; its approval gate stays mandatory and its undo stays tested — a deploy saga that cannot roll back is worse than no automation.

Reference Systems — the stack packages itself. The same governed-deployment pattern that ships an app also ships the runtime stack itself. v6 packages Context Runtime + Mission Runtime + ReDevOps RAG as a single-command Helm chart — the redevops-runtime Reference System — the deployable face a vendor solution blueprint has. The difference is that the install is a mission: a post-install verification hook runs the acceptance checks as a governed gate and fails the release if they fail (the deployment equivalent of a mission that holds instead of silently proceeding), and the runtime it installs is configured for deterministic execution out of the box — deny-by-default capability grants, an event-sourced replayable ledger, verification on. The chart's Kubernetes objects are the packaging; the acceptance gate is the governance; nothing about execution semantics moves into the chart.

This is deliberately the peer to a hardware-vendor blueprint — e.g. AMD Enterprise AI's Agentic RAG (an MCP server + ChromaDB + a reasoning agent, Helm-on-Kubernetes, single-command, on Instinct/ROCm). The two standardize different axes: a vendor blueprint standardizes deployment reuse (packaging, one-command installs, tuned hardware paths); the runtime standardizes execution reuse (planning, provenance, replay, verification). They compose rather than compete — the Reference System runs on the same Supermicro AMD Instinct (MI300X/MI350X) nodes via a bundled ROCm/vLLM model server, or beside a vendor blueprint consuming its endpoint. Deployment reuse and execution reuse are different problems; v6 ships both without collapsing one into the other.

Terraform + Ansible

Sidekick's deployment backbone is a clean division of labor. Terraform owns the substrate — the declarative desired infra: Proxmox VMs and LXC on the home node for the local proof subset, AWS EC2 for the heavy cores (PostHog and Wazuh, per the footprint plan in OSS_CORES.md), the container registry, DNS and cloudflared tunnels, networks and firewall. Terraform state is the source of truth for what infra exists. Ansible owns configuration and rollout — the convergent config: install Docker and compose, pull the operator and core images from the registry along the existing build-on-control-node → registry → host-pull path, render each app's compose and .env, run seeds and migrations, and health-check /health and /capabilities. Playbooks exist per app and core, plus a fleet playbook; Ansible already deploys the stack today, so v6 slots Terraform under it and Sidekick over it.

agentic-os-stack/
  deploy/
    terraform/
      modules/{proxmox-lxc, ec2-core, registry, cloudflared, network}/
      envs/{home-proxmox, aws-heavy}/          # per-target root modules + state
    ansible/
      roles/{docker, registry-login, app-operator, oss-core, seed, healthcheck}/
      playbooks/{fleet.yml, app.yml, core.yml} # app.yml: image pull + compose + seed + health
      inventory/                                # hosts grouped by core footprint (local vs EC2)
  agents/<app>/…                                # the operator lives with the app (canonical)

Sidekick orchestrates the two: sidekick deploy <target> is terraform apply for infra, then ansible-playbook for config, then post-deploy verification, with state and secrets wired through. One authoritative Terraform state per target, and Ansible never mutates what Terraform owns; existing infra is imported into state before the first apply. Secrets are pulled from the permissions plane or a vault, injected at apply time, and redacted from evidence records — they never enter the event log.

SkyPilot: multi-cloud placement as a self-learning optimizer

Terraform owns what infra exists and Ansible owns how it is configured — but neither decides where a workload should run when the answer spans clouds, regions and a live spot market. That placement problem is exactly what SkyPilot (the open-source multi-cloud runtime) already solves: its optimizer picks the cheapest cloud/region/instance that satisfies a resource spec, fails over across regions and providers to wherever GPUs are actually available, runs managed spot with automatic recovery, and autostops idle clusters. v6 does not reimplement any of that — it wraps SkyPilot as a capability provider, so a sky operator slots beside Terraform and Ansible inside the same governed mission.

sky.optimize   rank {cloud × region × instance × spot} by live price + availability
               → the ranked table is EVIDENCE presented at the approval gate
sky.launch     provision the chosen candidate     [gate: approval]  side_effecting
               ↳ on capacity/quota failure → fail over to the next candidate
               undo = sky.down
sky.serve      replicas · autoscaling · readiness (SkyServe), gated on scale-up cost
sky.down       autostop / idle-teardown — as a GATED mission, never silent   (saga comp.)

  the self-learning loop
  workload spec → sky.optimize → [gate] → sky.launch → measured outcome ──┐
        └──────────────  reward (cost · capacity · preemption · ttr)  ←────┘

The fit with the rest of the OS is the self-learning loop. SkyPilot's optimizer is a one-shot estimate; under Sidekick, the measured outcome of each provision — the real cost, whether the region had capacity, how often spot was preempted, time-to-ready — feeds back as a reward, exactly as the decision engine already learns retrieval and plan selection from measured cost (Whitepaper v4). Placement stops being a static price lookup and becomes learned per workload: the runtime discovers, from its own history, which cloud/region/spot configuration actually delivers for this kind of job, and drifts toward it as prices and capacity move. And because every step runs as a mission, the optimizer's cost table is evidence a human approves, cross-provider failover unwinds through the saga, and idle-teardown asks before it acts — SkyPilot's economics, under mission governance.

The three stacks

Three stacks wrap the loops, and each leans on data the runtime already owns rather than instrumenting from scratch.

Observability owns the data no one else has. EXPLAIN, the event-sourced timeline, world/belief, the evidence ledger and the saga are already emitted; v6 exports node-level spans to OTEL and Langfuse while keeping the cockpit as the primary lens (Graph / World / Timeline / Explain / Evidence). Deploy missions land in the same lens — an infra change is observable exactly like a business mission.

Monitoring watches fleet /health and mission SLOs — success rate, p95 latency, budget burn, approval-queue depth, and stuck or aging missions — feeding a control-tower / Metabase dashboard (the control-tower operator already exists), with alerts on failed or stuck missions, gate backlog and budget breach.

CD is deploy-only: Terraform + Ansible via Sidekick, gated by Mission CI and human approval (a vulnerability scan gate is planned, not implemented today), with ingress via cloudflared. There is no code CI.

Mission SDK

Authoring is the first loop, and v6 gives it a language. The Mission SDK declares missions and capabilities as code — decorators and a DSL over the existing templates.py and operator manifests — so a mission is described, not hand-assembled, and a capability is a typed, metered, permissioned declaration rather than an ad-hoc call. The point is that you author missions and capabilities, not agent loops: the SDK captures goal, constraints, policy, budget and the capability surface, and Sidekick scaffolds a new mission or operator from it. This is what makes the pipeline definition a first-class artifact the rest of the system can test and ship.

Mission CI

Mission CI is the test-before-ship stage, and its primitives already exist in the kernel — v6 assembles them into a gate. sidekick mission ci <mission> runs the pipeline: simulate the projection, policy-prune the candidate plans, verify against evidence and assertions, replay from the event log, and regress against a library of golden missions. A cockpit CI tab surfaces the results, and promotion gates on it — a mission that fails a regression is blocked from promotion. Mission CI is one of the two gates the deploy saga honors: no mission ships red.

simulateproject cost · success · latency · approvalspolicy-prunedrop inadmissible / policy-violating branchesverifyevidence + state assertionsreplayreconstruct from the event logregressiongolden missionspromotion gateno mission ships red
sidekick mission ci <mission> assembles kernel primitives into a gate: a mission that fails a regression is blocked from promotion. It is one of the two gates the deploy saga honors.

Context Runtime compiler & the representation engine

Underneath the loops, v6 formalizes the planner as a compiler. A mission lowers through a pipeline of representations — Mission → Execution Intent → Execution Graph → Capability Graph → operators — the same lowering the runtime already performs, now named and back-compatible so the compiler emits exactly the graph the runtime executes. This is the machinery that lets a mission be reasoned about, simulated and verified before anything runs.

Missionthe business objectivethe goalExecution Intentwhat must be trueoutcomes & needsExecution Graphordered plan · gates · verificationthe planCapability Graphthe syscalls the planner composessyscallsOperatorsthe 15 apps that own implementationsimplementationscompile
v6 formalizes the planner as a compiler: a mission lowers through named, back-compatible representations, so it can be reasoned about, simulated and verified before anything runs — and the compiler emits exactly the graph the runtime executes.

Alongside the compiler, the ReDevOps-RAG representation engine gains structured and analytical adapters — SQL, Mongo and Elasticsearch — bound through the analytical representation, with cost-routing intact. An analytical mission routes a structured query to the real DB retriever rather than flattening everything into semantic search, and the schema-specific query reaches the store that can answer it.

Retrieval is a fleet of interchangeable plugins, not one engine. Every retriever — hybrid dense+BM25, DIVER reasoning-retrieval, HippoRAG and SimGraph knowledge-graphs, the temporal store, the structured adapters, the document-visual arm — is a plugin behind one seam. Because they share that seam, Context Runtime can iterate over many retrieval plugins and learn which one fits each corpus and question class — the same measured, per-mission-class routing it applies everywhere: a multi-hop question to the graph engine, a point-in-time question to the temporal store, a domain corpus to the encoder its language routes to. Retrieval is fine-tuned per dataset by measurement, not fixed to a single index; adding a new engine (a LightRAG, a ColPali doc-visual model) is registering a plugin, and the planner starts routing to it where it wins.

v6 also makes those engines live: HippoRAG, SimGraph and DIVER gain incremental inserts — a growing corpus (new tickets, edited docs, fresh sessions) extends the index or knowledge graph in place instead of triggering a full rebuild. The graph engines add only the new documents' entities and edges (no re-extraction of the whole corpus); the reasoning-retrieval arm, being index-free, sees new documents on the very next query. A knowledge base that changes by the hour stays current without a costly re-index.

Reasoning-effort control: the Reasoning Plane learns how hard to think

The frontier ships reasoning "effort" as a menu — Light to Ultra. We ship it as a learned per-mission-class decision, on any served model.

v5's Reasoning Plane treats the answer strategy — terse · reason · decompose · mapreduce, thinking on or off — as a bandit arm keyed by mission class, learned from measured reward the same way retrieval is. v6 extends that arm set into a full effort ladder, so the runtime learns not just how to reason but how hard, and spends compute only where it pays. Four additions, each a distinct arm (method:strategy[+sc][+v]:tier) the bandit can pick or skip per class, all opt-in and byte-identical to v5 when off:

The through-line is the same orthogonal-optimization thesis retrieval follows: route the encoder on the corpus, the retriever on the regime, the model on measured competence — and now the reasoning effort on the mission class. Effort is not a global slider the operator guesses; it is a governed, measured decision the runtime learns, and shows its work for.

How testing shaped this ladder (honest): a first ablation showed the reasoning-effort tiers not paying and apparent capacity ceilings on the aggregation/temporal classes — but auditing the data traced those ceilings to evaluation artifacts (retrieved context truncated below the gold length; a mislabeled long-form dataset), not model capacity. Discarding that false wall reshaped the design: “escalate to a bigger model” gave way to a thinking pass over the full context, chosen per class because it helps temporal/aggregation but hurts multi-hop; a code-side deterministic aggregator was dropped once full-context reasoning beat it; and the heavier tiers (+sc, +v) stay opt-in and default-off until their own ablation earns them. The durable lesson: audit the evaluation before declaring a wall. The measured results behind these choices are on the reasoning benchmark.

Sidekick → Mission Supervisor

Sidekick is to Mission Runtime what kubectl is to Kubernetes — the Sidekick Mission Supervisor over the three runtimes.

Sidekick becomes the OS shell — one surface, over the cockpit API, for launch, observe, approve, replay, govern and now deploy. It is both the Mission Supervisor that schedules, persists, monitors and recovers missions, and the deployment arm that drives Terraform and Ansible. The endpoint of the design is a single workflow: a change to an operator flows author → Mission CI → approval-gated deploy → observed run, entirely from Sidekick and Projects, with no step leaving the governed surface.

Extending the OS: trust, code-aware retrieval, lifecycle hooks & a monitoring agent

Four capabilities harden the same invariant the OS already rests on — orchestration decides; extensions state needs and act only through granted capabilities — and one packages the result as a standing deployment. They are dependency-light, tested, and mirrored in the Python and Go kernels.

A capability trust boundary. A capability whose source is a third party — a plugin, a cloned repo, an external registry — is an execution surface. So the Context Runtime treats untrusted sources the way a plugin host does: they are still discovered and listed (the registry returns them, metadata-only), but they are not bindable until the source is trusted — the bind door fails closed. Built-in capabilities are trusted by default, so nothing existing changes. Discovery is safe; execution is gated — the same posture as the read-only demo surface, generalized to the syscall layer.

A code-aware retrieval arm. The representation router gains a code representation: a structural scope-graph over a codebase (definitions · references · symbols) that answers “where is X defined” / “what calls X” over an AST index rather than by semantic similarity — the code analog of the graph arm, and the retrieval a coding/DevOps Sidekick actually needs. It joins vector, temporal-graph, multi-hop and analytical as one more arm the cost-based router selects by query shape.

Lifecycle contributors. The runtime dispatches data-only events at mission phases — started · node-completed · gate-reached · finished · idle — to installed contributors. A contributor receives only data at dispatch time, acts only through capabilities injected at install time, and never owns loop control (a raising contributor is swallowed; it cannot alter the plan or steer the scheduler). This is the same contract as the resolve door, applied to observation and side-channels — the clean seam for evidence, metrics, the monitor loop, and alerting.

Context compaction. An opt-in policy for any session that carries an LLM conversation: auto-compact at a threshold, an optional memory flush (pull the durable facts out before the history is summarized away), a two-pass fold, and a wall-clock budget — the backstop for a reasoning runaway that a token limit alone misses.

The monitoring agent. Packaged as a standing container (Docker Compose, or a Helm chart with a read-only cluster ServiceAccount), Sidekick becomes a continuous monitoring agent: the monitor loop reads live signals (metrics-server / Prometheus / Loki), and when a rule fires it spawns a governed response mission that parks on its approval gate. A lifecycle AlertContributor turns that gate into a stakeholder sign-off alert — a webhook message (Slack-compatible) with a cockpit deep-link — so the path from issue detected to a human approves the fix is fast, and every action still passes a gate. It reads read-only and mutates nothing without sign-off.

PRODUCTION CLUSTER / SERVERworkloadsthe live deploymentSidekickstanding monitor loopread-onlymetrics-server · Prometheus · Lokistakeholderapproves via cockpit deep-linkgate → sign-off alert (webhook)the loop lives on the infra — the client's machine can power down
Packaged as a standing container (Helm with a read-only ServiceAccount, or Compose), Sidekick is a continuous monitoring agent: a fired rule spawns a governed response mission whose gate becomes a stakeholder sign-off alert. It mutates nothing without approval.

Roadmap

Each phase is independently shippable; later phases assume earlier ones. The sequence puts reliability and real deploys before optimization, and the SDK and CI before broad authoring.

PhaseTitleDefinition of done
6.0Production wiring + repo canonicityRevenue Rescue + Onboarding run from the cockpit against the live operators, with gates + saga.
6.1Terraform/Ansible CD + SkyPilot placement + deployment-as-a-missionOne app deploys end-to-end as an approved, gated mission — with a SkyPilot-optimized target (ranked cost/availability as gate evidence) and cross-cloud failover on capacity — and a demonstrated saga rollback on induced failure.
6.2Mission SDK + Mission CIA mission is authored via the SDK and blocked from promotion by a failing regression.
6.3Observability + monitoring stacksA stuck mission and a failed deploy both raise alerts and are inspectable in the cockpit + dashboard.
6.4Context Runtime compiler + RAG representation engineAn analytical mission routes a structured query to a real DB retriever; the compiler emits the same graph the runtime executes.
6.5Sidekick → Mission Supervisor + Mission DevOpsA change to an operator flows author → Mission CI → approval-gated deploy → observed run, entirely from Sidekick/Projects.

Conclusion

v5 made the business objective the unit of execution. v6 makes it the unit of delivery. By treating Projects as the mission DevOps control plane and Sidekick as its CLI and deployment arm — and by running deployment itself as a governed mission on Terraform and Ansible — the same guarantees that make a business mission safe (gates, evidence, replay, saga rollback) now make shipping safe too. Author, verify, deploy, run, observe: one operating system, one governed surface, driven by Sidekick.

Amendment (v10-era) — versioned Mission programs, governed memory, forensic timelines

Three additions position v6's control plane under the reference-first harness of v10.

MissionProgram — versioned, replayable loops

Orchestration loops become versioned programs (id · version · goal_class · state_schema · steps · branching_rules · loop_conditions · completion_conditions · budgets · gates · failure_policy · verification_policy · event_schema) — normal code or declarative graphs that are unit-tested, traced, replayed, with deterministic completion, pause/resume, bounded model-editable regions, and human-approval gates. Example programs: research investigation; personal financial scenario; large code integration (collect worker artifacts → contract merge → module merge → subsystem verify → architecture merge → release verify).

Scratch versus durable memory

The governed graph (Evidence/Finding/Decision/Assumption/Investigation/Run) stays the memory. A bounded scratch layer (WorkingNote) never affects claim status or policy; promotion to durable knowledge requires typed output, provenance, verification, a Mission association, and policy approval. Model reflections are proposals, never canonical. The same rule governs the normalized event stream: RuntimeEvents are raw observation, not truth.

Append-only forensic timelines

Mission state gains the ContextView (v10) as the governed unit between Mission and each model call, and each Mission preserves a physically-ordered, append-only timeline: earlier actions are never erased on a model rewind, abandoned branches and superseded tool proposals are retained, subagent parentage is recorded, and states are distinguished as proposed · attempted · completed · failed · observed — the substrate for replay and trajectory analysis.

Corrections (2026-11-01)

An earlier version of this page said that edge-sentinel scans container images and that no image ships with a critical CVE. That was wrong. Edge Sentinel does not scan container images today, no deploy or mission is gated on CVE results, and the supply_chain_scan step existed only as a test stub. The scan step in the deploy_app diagram is now marked planned, and the phrases "supply-chain-gated" and "audited deploys" are replaced by "approval-gated" and "a recorded history".

What Edge Sentinel does today: threat triage over a self-hosted CrowdSec and an approval-gated response, which is a dry run in the demo. It is demonstrated on sample data. Image and dependency vulnerability scanning is planned and not implemented. This correction follows a check of the Edge Sentinel code and live demo on 2026-11-01.

Context Runtime — private pitch. Not for distribution. © 2026 redevops.io  ·  Whitepaper v6 (draft) — Sidekick-driven Mission DevOps
redevops.io is a member of the NVIDIA Inception program.
© 2026 NVIDIA, the NVIDIA logo, and NVIDIA Inception are trademarks and/or registered trademarks of NVIDIA Corporation in the U.S. and other countries.