← redevops.io
Roadmap · route to Public · redevops.io

Platform roadmap

The route every plane takes to public — most are now there, validated by live demos and benchmarks; a few remain.
The Architecture spec labels each production plane honestly. As of the v0.3.x line, most planes are now public — validated by a live Apps Demo and/or a benchmark, with a docs surface. A handful remain preview: the two enterprise planes still awaiting a pilot (multi-tenancy, metering) and two with no dedicated validation surface yet (policy plane, model gateway). This page records what promoted each plane and what the remaining ones still need.

We label to a strict bar. A plane is Public only when it is shipped, documented, and validated end-to-end — here, by a live Apps Demo deployment and/or a benchmark, not merely running. The nine planes below marked public each cite the demo or benchmark that validates them. The four enterprise planes remain private until a pilot deployment tests them thoroughly — two are still there. Honest status beats optimistic status; that is the point of the ladder.

Recently landed

Merged, conformance-tested, benchmarked and (where noted) documented. These are marked landed — code shipped and evidenced — not public, which additionally requires the full seven-criteria gate (docs + pilot). Two of them also fill gaps the plan did not previously name: safe concurrency as a first-class, cross-language contract, and a measured open↔enterprise differential.

What landedStatusDetail & evidence
Safe concurrency (advances Phase 2 · mission leases & concurrency)landedResource/conflict-key scheduling — parallelize what is safe, serialize what must be, with an auditable reason (serialized: resource_key=… at limit 1) — plus bounded provider fan-out, branch-local approvals, exactly-once siblings, governance containment, parallel wave execution and startup/EXPLAIN telemetry. Conformance-tested and benchmarked (Family 2 · 2A–2F). Directly satisfies the Explain gate for scheduling: why each node ran concurrently or was held is on the record.
Cross-language parity — now +KotlinlandedThe safe-concurrency contract is now conformance-tested across Python, Go and Kotlin — the same decisions in three independent implementations (previously the plan tracked only Python↔Go). One user-facing SDK concurrency control, with the effective limit observable so the two ceilings can never silently diverge. write-up →
Cross-language parity — identity & discoverylandedParity now reaches past concurrency to the identity layer. The boundary seal artifacts (authorization_chain · binding · proposal) are conformance-tested bit-identically across Python, Go and Kotlin — independently re-derived from the rules, not shared code — and the VerifiedIntent intent contract's intent_hash is reproduced in Go. In review on the same conformance basis: the Intent-Discovery runtime (readers → fusion → clarification → seal) in Go and Kotlin, the Kotlin intent contract, and the Kotlin execution-planner ↔ capability resolution (Phase 2 · planner + capabilities).
Open ↔ Enterprise differential (not previously in the plan)landedA falsifiable acceptance rule and a PARITY / HARDENED_DELTA / BUG classification harness proving the open (AGPL) and enterprise runtimes execute the same workload the same way — the hardening is additive, not a fork of the execution semantics. Benchmarked + documented: the differential → · the write-up →
Identity & access — evidencepreviewDeny-by-default authority + the hash-chained access ledger are now demonstrated end-to-end in a benchmark (authorized → hash-chained audit + verification; unauthorized → 0 nodes executed). Strengthens the Tests + conformance criterion; the route to Public is unchanged (still needs an SSO→gated-action pilot + docs).
Code retrieval — graph ∪ content (informs Phase 3 · capability plane / retrievers)previewA benchmarked finding: for a coding change the unit of relevance is a change closure (definition + every caller whose contract breaks), not the nearest snippet — so retrieval is scored by whether the edit resolves (applies + passes tests). Content retrieval (dense hybrid) and structural call-graph traversal have complementary blind spots; their union recovers the closure under a fixed token budget and — the result that matters — the retrieval lift converts to resolution (0/2 → 2/2 on the discriminating families, matching the oracle ceiling). One earned graph edge (INSTANTIATES) + 5 frozen families. Ownership is settled: ReDevOps RAG owns the code_graph retrieval plugin; Context Runtime owns the graph ∪ content composition strategy — not a new runtime. Route to Public: benchmark family expansion, then promote the representation on measured resolution — gated, not yet a default. the write-up →
Agentic-apps layer — v0.1.0 (the golden path, productized)landedFull vertical applications on the Mission architecture, tagged v0.1.0 — most visibly the AI-native accounting firm: CPA-signed IRC §41 R&D credit study + ASC 606 memo, a claim graph with typed provenance, deterministic engines with independent A/B cross-check, a governed sign gate over a hash-chained ledger, and a review console that lets you challenge any line and trace it to a runtime plane. Exercises Control · Capability · Data-context · Governance end-to-end.
Runtime release — v0.3.1 (supersedes the v0.2.0 milestone below)landedThe runtime stack advanced to the v0.3.x line (agentic-os v0.3.1): the closed outcome/learning loop (observe → attribute → OutcomeLink → governed selection), Governed Assist (safe READ-tier auto-interventions), shadow evaluation + a candidate learned-policy with a promotion gate, and durable Postgres persistence. The mission-sdk front door pins the runtime by release tag.

The maturity ladder

plannedDesigned, not built. A contract sketch and a place in the architecture — no running code yet.
→
previewImplemented and running in the reference stack, but the public contract, docs and hardening are incomplete.
→
publicShipped & documented — a stable contract anyone can build on, with docs, tests and a reference deployment.

The universal gate — what "Public" requires

Regardless of plane, promotion to Public means meeting the same seven criteria. The per-plane "route to Public" below is just this gate made specific.

  1. Stable public contract — a versioned API / schema / config surface that will not break under you.
  2. Documentation — an under-the-hood / reference page and a worked example.
  3. Tests + conformance — unit + integration tests, and a conformance or benchmark suite where the plane makes measurable claims.
  4. Reference deployment — running end-to-end in the reference stack (demo.redevops.io / quantify.club / the proxmox cluster), not just on a laptop.
  5. SDK / manifest surface — reachable from the Python & Go SDKs and declarable in the Project Manifest.
  6. Security review — permissions are deny-by-default, side effects are recorded, and the plane passes the continuous-compliance checks.
  7. Pilot-validated — exercised end-to-end in a real pilot deployment before promotion. A private plane is not promoted on the strength of tests alone.

Route to Public — every plane

Where each plane sits, and what validated it. Nine planes are now public, each citing the live Apps Demo and/or benchmark that exercises it end-to-end. Four remain preview: multi-tenancy and metering are built but await a pilot; policy plane and model gateway are running but have no dedicated validation surface yet.

PlaneStatusRoute to Public — the gate
Control planepublicValidated live: the Execution Canvas demo runs a mission end-to-end, and the Accounting deliverable runs the full golden path (ingest→reconcile→compute→verify→sign); mission leases & concurrency benchmarked (Family 2); the Control Plane page as its docs. Backup/restore + desired-vs-observed reconciliation across dev→prod remain the hardening edge.
Identity & accesspublicValidated: the Permissions demo resolves scoped grants deny-by-default (row/column), and the identity benchmark shows authorized → hash-chained audit / unauthorized → 0 nodes executed. Enterprise SSO/federation depth stays enterprise-only, pending a pilot.
Policy planepreviewOne policy service with a public rule schema; proven to prune plans before model/learning calls in a conformance suite; residency + budget + PII rules documented. (no dedicated demo/benchmark surface yet — stays preview.)
Model gatewaypreviewProvider-agnostic contract + cost-aware router exercised by every app; token/cost accounting reconciled against bills; structured-output validation + allowlists + DLP by default; OpenAI-compatible endpoint documented. (exercised broadly but no dedicated validation surface — stays preview.)
Data & context gatewaypublicValidated: live connectors — CRM (Twenty), GRC/KYC — plus ReDevOps RAG grounding in the Accounting deliverable and the redevops-connectors IntegrationAdapter SDK (≥3 reference connectors, OAuth/SecretRef, conformance fixtures).
Capability registrypublicValidated: every model/tool/agent/retriever registered through the Capability contract and exercised across the App Stack and the Accounting deliverable (provider/resolver plugins); retriever capabilities benchmarked (code-retrieval).
Observability & evaluationpublicValidated live: the Evidence Explorer demo — SQL over a run's saved canonical evidence, one trace with cost/latency per node. The three eval tracks + OpenTelemetry export remain the hardening edge.
Continuous compliance & AI securitypublicValidated live: the Compliance demo (control posture · framework crosswalk · can it govern itself?) and the Intrinsic Security demo (decisions · telemetry · containment) run the checks as a standing cross-cutting service that emits governed remediation, over an evidence ledger.
Governance & trajectorypublicValidated live: the Governance Plane demo enforces cross-agent trajectory rules end-to-end; one normalized cross-runtime event ledger + live DecisionGate with Python↔Go conformance (trajectory benchmarked). Shipped: cross-series (evidence-aware) rules and OBSERVE/ENFORCE modes (P5). Remaining: population controls + the SDASI rule master (P3–P4).
Sandboxed executionpublicOpen reference membrane validated via the Intrinsic Security demo (containment): ExecutionEnvelope/Receipt, per-mission fs boundary · rlimits · wallclock · egress allowlist, hash-chained provenance, signed outputs, verification ladder. The hardened OS-namespace / microVM / remote tier stays enterprise, pending a pilot.
Multi-tenancypreviewBuilt: tenant scoping (cross-tenant fail-closed), per-tenant HKDF keys, provider-key isolation, quota limiter, prove-clean deletion. Gate: two isolated tenants in a pilot + docs. (one of the few remaining.)
Metering & commercial opspreviewBuilt: hash-chained usage stream, budget guard (deny before spend), invoices, SLA reports, export/delete. Gate: metered usage → invoice + SLA in a pilot + docs. (one of the few remaining.)
SDK & compatibilitypublicValidated: the mission-sdk front door (author/validate/explain/run/replay + rdo CLI) with LangGraph + LangChain adapters; Python + Go + Kotlin conformance benchmarked. Helm + Terraform packaging remains the hardening edge.

Strengthened governance — new in v0.2.0

The v0.2.0 release adds a Governance & trajectory plane: the missing layer that governs a population of agents over time, not one action or one mission. It closes a concrete running-code gap — trajectory rules exist today only as a Go library plus a spec, never wired as a live cross-agent service — and directly answers the multi-agent failure modes (conformity collapse, resource flooding, collusion, turf-war escalation, epistemic brittleness) that Anthropic frames as open problems. It reuses ReDevOps's existing durable execution, replay and saga — the very primitives Anthropic names as missing.

v0.2.0 is the foundation, not the whole system. The hard v0.2.0 commitment is P1–P2 plus the public-claim corrections: one normalized, immutable event ledger and a live cross-agent trajectory service with Python↔Go conformance. The ledger is the architectural boundary — RuntimeEvent[] → Governance Plane → GovernanceFinding → Mission enforcement — so nothing couples to the trajectory implementation. Behind it sit two separate engines (a trajectory/population engine and an epistemic authority-weighting engine) sharing the ledger, policy master and finding contract. P5 (Mission enforcement — OBSERVE/ENFORCE) and cross-series (evidence-aware) governance are shipped (v0.3.x) and the plane is validated live via the Governance Plane demo; P3–P4 (population controls, the SDASI rule master) build out next.

Governance & trajectory preview · new in v0.2.0

Governance today is per-action (permissions plane, agent-harness) and per-mission (Mission Runtime: risk-scored approval, saga, versioned policy, replay). Nothing evaluates a pattern spread across agents and missions — where each individual step passed its local check but the sequence is a flood, a collusion, or an escalation. That cross-agent layer is the gap.

Build on: the Go TrajectoryEngine/DecisionGate + the security under-the-hood spec; Mission Runtime's durable approval / saga / replay; and the SDASI governed-decision lifecycle (registry · judge · versioned master). Trajectory rules exist in Go; the running cross-agent service + Python parity is the gap.

v0.2.0 exit gate: one normalized cross-runtime event ledger + a live trajectory service + Python↔Go conformance + a fail-closed DecisionGate + a coverage matrix + at least one genuinely cross-agent trajectory detected and replayed end-to-end. Coverage honesty is load-bearing: the plane reports DENY only where a synchronous pre-action gate provably exists — otherwise OBSERVE. Route to Public then adds docs + pilot per the universal gate.

The enterprise planes — two validated, two pending pilot

These four planes are all implemented (Python + Go, at field parity). Two now have a validated tier that is public: Identity & access (scoped grants deny-by-default, via the Permissions demo + the identity benchmark) and Sandboxed execution (the open 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 private until a pilot deployment validates them. Each plan below is unchanged; the pill marks how far the plane has been validated.

Identity & access preview

Every capability call already runs under permission grants, but there is no first-class identity plane: no SSO, no service/workload identity, no ABAC, no break-glass, no unified access audit. Capabilities must be denied by default and every grant attributable to an identity.

Build on: the existing permissions plane (agentic_os/permissions.py · permissions_api.py), the Project Manifest's capability grants, and safety.py. The RBAC + scoped-grant primitives largely exist; identity + federation is the gap.

Route to Public: a user logs in via SSO, receives a scoped grant, and a gated action is allowed or denied by policy — end-to-end in the reference stack, deny-by-default, with the full access audit and an under-the-hood page.

Sandboxed execution preview

Coding agents and tools run gated today, but not isolated. A per-mission sandbox is the boundary that lets an agent write code, run commands and touch a filesystem without risking the host or leaking credentials.

Build on: Sidekick's operator model (dry-run · approval · audit) and the Mission Runtime evidence ledger (the natural home for recorded side effects). The gate/approval layer exists; the isolation + provenance layer is the gap.

Route to Public: a coding-agent mission runs entirely inside the sandbox with ephemeral creds and an egress allowlist, its side effects land in the ledger, its outputs are signed — demonstrated in the reference stack with the conformance suite green and a docs page.

Multi-tenancy preview

The runtime has a tenant concept (the reference tenant, per-corpus routing), but not enforced isolation: shared indexes, shared keys, no per-tenant budgets or deletion workflows. A hosted offering needs hard tenant boundaries.

Build on: the Project Manifest's tenant/deployment identity, the demo's tenant scoping (ReDevOps Pilot Development), and the Context Runtime's multi-corpus routing (CR_TENANTS). Tenancy is a label today; it needs to become an isolation boundary.

Route to Public: two tenants run in the reference stack with separate state, indexes, keys and budgets; one tenant's export and full deletion are demonstrated without touching the other; an under-the-hood page documents the isolation model.

Metering & commercial ops preview

Cost and latency are already measured per node, but that telemetry is not turned into accounting: no usage records, budgets, invoices, SLA reports or customer export. This is what makes it a hosted service, not a demo.

Build on: the observability plane (cost/latency per mission & node) and the mission Budget primitives. The measurements exist; the metering + billing pipeline is the gap.

Route to Public: metered usage produces an invoice and an SLA report in the reference stack, tenant budgets enforce an overage policy, and a customer can export and delete their data — with a docs page.

Implementation sequence — contracts before features

The first milestone is consolidation, not expansion. The architecture is complete enough; the real risk now is implementing multiple partial versions of the same abstraction across repositories. So the sequence starts by freezing the contracts — and does not begin large integration work until they compile and round-trip across repos — then advances one plane at a time, each behind the gates below.

PhaseDelivers
Phase 0
Ratify contracts
Freeze the canonical schemas (ExecutionPlan, Capability, DiscoveryProposal, mission-event & evidence contracts); Python/Go serialization parity; a schema-versioning policy; compatibility wrappers for existing types. No large integration work until these compile and round-trip across repositories.
Phase 1
One golden path
One complete vertical flow — StateDelta → DiscoveryProposal → ExecutionPlan → mission graph → context operation → approval → safe side effect → verification → outcome → learning — on one real demo (the RAAAL paper-rebalancing mission or the lead-discovery pilot). Not every domain at once.
Phase 2
Production control plane
Project Manifest & registry, environment/tenant model, SSO/RBAC, secret references, mission leases & concurrency, backup/restore, audit export, desired-vs-observed reconciliation. preview control plane + the (now-built, preview) identity plane.
Phase 3
Capability plane
Standardize models · retrievers (lexical · dense · hybrid · code_graph) · SQL · property graphs · APIs · tools · humans behind the one Capability contract, with side-effect declarations, versioning, and quality/cost/latency stats. ReDevOps RAG registers as one capability, not specially wired — and Context Runtime composes its representations (e.g. graph ∪ content) per step under one budget.
Phase 4
Unified telemetry & evaluation
One trace from discovery to outcome — proposal_id → plan_id → mission_id → node_id → capability_id → evidence_id → verification_id → outcome_id. Without it, learning, governance, billing and debugging fragment.
Phase 5
Security & continuous compliance
Prompt-injection controls, tool-abuse prevention, capability allowlists, MCP provenance, supply-chain verification, sandboxed execution, data classification, policy/infra drift, evidence-generating compliance missions — platform-wide. Edge Sentinel, the security demo app, is described by what is implemented, demonstrated and planned in its own section below.
Phase 6
Packaging & adoption
Compose quickstart, Helm chart, Terraform modules, sample Project Manifests, a migration guide from ordinary agent frameworks, a production reference deployment, operational runbooks, upgrade-compatibility tests.
Phase 7
Multi-tenant enterprise plane
Only after the single-tenant golden path is stable: tenant encryption & isolation, quotas, provider-key isolation, regional routing, chargeback & metering, an HA control plane, distributed scheduling, policy inheritance.

The four now-built enterprise planes slot into this order by their dependencies: Identity & access in Phase 2 (the sandbox needs it for ephemeral credentials, multi-tenancy for principals); Sandboxed execution in Phase 5; Multi-tenancy then Metering in Phase 7 (metering consumes per-tenant accounting + the observability usage records). Each is implemented but stays private until pilot-validated. In parallel, each preview plane walks its one-line gate above to Public — mostly hardening + a docs page + a reference deployment, since the implementation already runs.

Edge Sentinel: implemented, demonstrated, planned (checked 2026-11-01)

Edge Sentinel is a dashboard and chat console over a self-hosted CrowdSec. It is not a standalone product, and it does not scan container images, gate deploys on CVE results, run control checks or produce an audit. Three states are used below: implemented means in code and exercised by tests; demonstrated means visible in the live demo, which uses sample data and a dry-run response; planned means not implemented.

CapabilityStateDetail
CrowdSec-backed threat triage (reads decisions, alerts and cases)implemented and demonstratedReads are live; the demo's CrowdSec currently holds no alerts, and its earlier history was seeded sample data.
Content-addressed cases built from alert evidenceimplemented and demonstratedCases are held in memory; only the approval decision is persisted.
Approval-gated IP bandemonstrated (dry run)The demo stages the action and records the approval; nothing is blocked.
Executing a real blockimplemented, disabled on the demoNeeds an operator credential and an explicit enable flag, both absent on the demo.
Network access review and backup status panelsdemonstrated on sample data onlyLabelled sample in the demo; not run against a live NetBird or backup service.
Vulnerability-intelligence table and SOC 2 readiness libraryimplemented as libraries, not deployedNot part of the demo and not reachable over HTTP. The readiness library produces evidence for a reviewer; it is not an audit or an attestation.
Image and dependency vulnerability scanningplannedNot implemented in Edge Sentinel; no deploy or mission is gated on it.
Control checks on a host or agentplannedNot implemented.
Standalone package and evidence exportplannedNot implemented; the demo needs a private image and supporting services.

Implementation gates

A phase is not complete until it passes these. They are deliberately about behaviour under stress, not features — a plane that ships without them is not Public, whatever the demo shows.

GateWhat it proves
ContractPython and Go serialize the same object and preserve its meaning.
ReplayA completed mission can be replayed from its event and evidence records.
PolicyNo side effect can bypass Mission Runtime policy enforcement.
FailureA failed capability or model degrades, retries, compensates, or abstains — without corrupting mission state.
ExplainThe system can explain why the mission exists, why the plan was selected, which alternatives were rejected, what evidence was used, what action occurred, and how the outcome affected learning.
DeploymentThe stack can be installed, upgraded, backed up, restored, and removed from documented packages.
ClaimEvery public product claim maps to a test, demo, benchmark, or clearly-marked roadmap item.

Release milestone — v0.2.0 shipped · superseded by v0.3.x

Shipped, and since carried forward onto the v0.3.x line. An architectural clean-up, not an expansion — the first delivery of the "contracts before features" discipline above, hardening the functional-core / imperative-shell split, with accelerator integration as the one net-new feature. Everything below landed; the runtime is now on v0.3.1 (see Recently landed).

What not to add now

No more top-level runtimes or branded abstractions. The taxonomy is already complete: Discovery Runtime, Execution Planner, Mission Runtime, Context Runtime, Projects, Sidekick, Capability Plane. A new feature should almost always become a capability, a plan axis, a policy, or a mission template — not a new runtime. The discipline this roadmap enforces is one implementation of each abstraction, shared across every repository.

redevops.io — Platform roadmap · route to Public. Status labels are honest by policy: Public means shipped and documented. © 2026 redevops.io