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.
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 landed | Status | Detail & evidence |
|---|---|---|
| Safe concurrency (advances Phase 2 · mission leases & concurrency) | landed | Resource/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 +Kotlin | landed | The 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 & discovery | landed | Parity 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) | landed | A 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 — evidence | preview | Deny-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) | preview | A 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) | landed | Full 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) | landed | The 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. |
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.
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.
| Plane | Status | Route to Public — the gate |
|---|---|---|
| Control plane | public | Validated 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 & access | public | Validated: 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 plane | preview | One 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 gateway | preview | Provider-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 gateway | public | Validated: 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 registry | public | Validated: 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 & evaluation | public | Validated 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 security | public | Validated 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 & trajectory | public | Validated 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 execution | public | Open 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-tenancy | preview | Built: 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 ops | preview | Built: 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 & compatibility | public | Validated: 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. |
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 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.
RuntimeEvent timeline (the precondition for everything else).DecisionGate/TrajectoryEngine to a running evaluator with Python parity; cross-agent / cross-mission correlation on mission · session · actor · agent. Monitor-first; DENY only where a synchronous pre-action gate exists; internal error → UNABLE_TO_DECIDE, never ALLOW.REQUIRE_REVIEW / DENY / Investigation mission) reusing saga + replay; publish the per-surface coverage matrix (who can DENY vs only OBSERVE). Shipped (v0.3.x): OBSERVE/ENFORCE enforcement modes (the same rule runs shadow or enforcing without changing detection; findings record rule_version + enforcement_mode) and cross-series evidence-aware rules → REQUIRE_REVIEW.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.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.
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.
IdentityPlane: principals (user · service · workload), roles, and scoped capability grants resolved deny-by-default at every syscall. Wire it into Mission Runtime's approval gates.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.
Sandbox capability with a container backend (gVisor / Firecracker / rootless containers) for tool + code execution, per mission node.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.
tenant_id as a first-class control-plane axis scoping all state (missions, world state, ledgers, discoveries, learning) — no query crosses a tenant boundary.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.
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.
| Phase | Delivers |
|---|---|
| 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 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.
| Capability | State | Detail |
|---|---|---|
| CrowdSec-backed threat triage (reads decisions, alerts and cases) | implemented and demonstrated | Reads are live; the demo's CrowdSec currently holds no alerts, and its earlier history was seeded sample data. |
| Content-addressed cases built from alert evidence | implemented and demonstrated | Cases are held in memory; only the approval decision is persisted. |
| Approval-gated IP ban | demonstrated (dry run) | The demo stages the action and records the approval; nothing is blocked. |
| Executing a real block | implemented, disabled on the demo | Needs an operator credential and an explicit enable flag, both absent on the demo. |
| Network access review and backup status panels | demonstrated on sample data only | Labelled sample in the demo; not run against a live NetBird or backup service. |
| Vulnerability-intelligence table and SOC 2 readiness library | implemented as libraries, not deployed | Not 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 scanning | planned | Not implemented in Edge Sentinel; no deploy or mission is gated on it. |
| Control checks on a host or agent | planned | Not implemented. |
| Standalone package and evidence export | planned | Not implemented; the demo needs a private image and supporting services. |
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.
| Gate | What it proves |
|---|---|
| Contract | Python and Go serialize the same object and preserve its meaning. |
| Replay | A completed mission can be replayed from its event and evidence records. |
| Policy | No side effect can bypass Mission Runtime policy enforcement. |
| Failure | A failed capability or model degrades, retries, compensates, or abstains — without corrupting mission state. |
| Explain | The 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. |
| Deployment | The stack can be installed, upgraded, backed up, restored, and removed from documented packages. |
| Claim | Every public product claim maps to a test, demo, benchmark, or clearly-marked roadmap item. |
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).
ExecutionPlan, Capability, DiscoveryProposal, mission-event & evidence contracts) collapsed into a single runtime-contracts package, ending the multiple partial copies that had accreted across repositories.Protocol interfaces — EventStore, readers, capabilities, and providers — so the functional core depends on interfaces, not concrete implementations.agentic-os, where it lives as shared platform code rather than app-embedded logic.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.