Reading guide · redevops.io
The ReDevOps Whitepaper Series
Eleven papers, one arc: from managing a model's context to a governed runtime that discovers, plans, executes and learns — the harness through which models touch it, and the governance that watches the whole agent population.
Use this page to find the right paper. Each entry is its thesis plus a short list of what it contains.
How to read the series. v1–v8 are the Context Runtime line — each picks one thesis and threads it through the stack. v9 is the portable implementation paper (the three runtimes on the JVM / Apache Spark / Databricks). v10 is the harness paper — how models interact with governed state by reference (and its Evaluation Runtime extension applies that substrate to running benchmarks). If you read three: v5 (the runtime as an OS), v8 (discovery + learning), v9 (how it executes portably). The current build focus elevates v6's Mission SDK + Mission DevOps into the platform's product boundary — the surface applications author against — with one compilation path and behavioral cross-language parity; see the developer boundary on the architecture page.
Foundations — managing context
v1 · Context Runtime read v1 →
The founding thesis: better models don't fix bad context. Context is a runtime problem.
- The problem: models, retrieval and agent frameworks improved; context assembly didn't.
- The thesis and the Context Runtime as a cost-based, self-optimizing layer.
- Architecture; open-source-first; the enterprise vision and market.
v2 · Context Runtime + observability read v2 →
v1 made measurable and inspectable.
EXPLAIN for context — observability into what the runtime selected and why.- Evidence: measured results.
- Refined architecture and enterprise framing.
v3 · Execution planning as a moving target read v3 →
Query-planner thinking for a non-stationary world.
- The five generations of the runtime.
- Online optimization — staying correct when statistics drift.
- Policy-constrained planning (enterprise governance); the shared-assistant pattern; enterprise scaling.
v4 · From retrieval planning to knowledge planning read v4 →
The question changes from "how to execute?" to "what knowledge, in what representation?"
- Why retrieval stops scaling; knowledge representations as first-class.
- Temporal knowledge made first-class; "capability is not context."
- Enterprise data as planning input; the roadmap.
The operating system — missions, evidence, planning, discovery
v5 · The runtime as an operating system read v5 →
Missions as the unit of computing; capabilities as the interface.
- Missions; capabilities-as-interface; the execution model.
- State: observed → verified → believed → committed; the Evidence Plane; verification shipped in the kernel.
- The Reasoning Plane; plan evaluation & simulation; policy-driven human operators.
v6 · Mission DevOps control plane read v6 →
Operating the runtime: Projects, deployment-as-mission, SDK and CI.
- Projects as the mission control plane; deployment as a governed mission (Terraform + Ansible + SkyPilot).
- Mission SDK and Mission CI; the Context Runtime compiler & representation engine.
- Reasoning-effort control; Sidekick → Mission Supervisor.
v7 · The Execution Planner — representations are access paths read v7 →
Knowledge representations are access paths; the planner scores among them.
- The query-planner argument; planner decision flow, interfaces and scoring.
- Representation composition; the property-graph case study; temporal knowledge as state reconstruction.
- Honest learning; benchmark methodology.
v8 · Discovery Runtime — what deserves attention read v8 →
The layer above the planner: deciding when work should happen, and learning what works.
- Discovery Runtime architecture; the self-learning loop.
- Flagship: self-learning insurance distribution; AI-native security operations.
- Formal interfaces; execution topology as the next axis.
Implementation & the harness
v9 · Portable AI Runtimes for Apache Spark (Kotlin) read v9 →
One specification, three implementations — the runtimes on JVM, Spark and Databricks.
- The three implementations; canonical contracts; the Kotlin module architecture.
- The semantic operator algebra (
merge / verify / promote / rollback / learn / explain); Mission Runtime and the Spark driver/executor boundary. - Discovery on Spark; the open-Spark profile and the Databricks subset.
v10 · Reference-First Context — a governed harness read v10 → draft
Models never observe artifacts directly — only ContextViews materialized by the runtime.
- The Architectural Law;
ArtifactHandle / ContextView / DereferenceEvent; context materialization and preview plans. - Model-callable graph APIs; append-only cache-preserving sessions; compaction as governed
merge(). - Harness-strategy selection; reference-first RAG.
- Amendments (v6–v9): the normalized
RuntimeEvent family, trajectory rules, a clean-decision gate, Mission Case Bundles, typed capability descriptors, prediction/residual, and the object store — implemented. - Extension — Evaluation Runtime: the same substrate applied to running AI benchmarks (Dataset → ContextView → Run → Verify → Publish → Finding). Implemented 12/12.
Governing the agent population
v11 · Governance Plane — cross-agent trajectory governance details → v0.2.0
The layer above per-action policy: what are agents collectively doing across missions and over time?
- Sequence / correlation rules over one normalized event history catch multi-agent patterns — conformity collapse, resource flooding, collusion, turf-war escalation, fragmented exfiltration — that no per-action check can see.
- A fail-closed
DecisionGate (internal error → UNABLE_TO_DECIDE, never ALLOW); a per-surface coverage matrix (a real DENY only where a synchronous pre-action gate exists, else OBSERVE); findings routed to Mission Runtime. - Foundation implemented (Python↔Go conformant); cross-series (evidence-aware) rules and OBSERVE/ENFORCE enforcement maturity implemented for the upcoming v0.2.x release; population controls + the epistemic (authority-weighting) engine follow next.
The arc in one line: v1–v4 make context a runtime; v5–v8 make the runtime an operating system that plans, verifies, discovers and learns; v9 makes it portable; v10 governs how models touch it; and v11 governs what the agent population does across missions and over time.