For decades the application was the unit of computing, and humans were the orchestrators — coordinating work by hand across email, calendars, CRMs, accounting, documents and enterprise software. Large language models added a natural-language interface but did not change that architecture; retrieval-augmented generation improved answers; Context Runtime v1–v4 added persistent memory, retrieval planning, verification, permissions, explainability and governance around the model.
The next step is larger. The unit of execution becomes the business objective. Context Runtime v5 introduces Mission Runtime — the execution engine of an Agentic Runtime that plans, supervises, executes, verifies and continuously improves long-running missions across applications, humans, AI models and external systems.
This is a different execution model, not merely better orchestration. Most agent frameworks run a short, ungoverned loop; the Agentic Runtime runs a full, governed lifecycle where planning, simulation, verification, learning and governance are first-class stages, not afterthoughts:
Each layer abstracts more operational complexity away from the user. Applications stop being destinations and become reusable capability providers; users stop orchestrating workflows and instead define goals, policies and constraints while supervising autonomous execution. Mission Runtime coordinates execution; Context Runtime maintains intelligence. Together they form the Agentic Runtime.
Language models reason well but are poor execution environments. They do not reliably maintain long-term state, permissions, evidence, workflow history, business policy, deterministic recovery, auditability or cost optimization. Those responsibilities belong in infrastructure, not inside a prompt. Context Runtime provides that infrastructure; Mission Runtime turns it into an execution engine for objectives.
There is a second reason, and our own benchmarks forced it. Context optimization alone is insufficient. Retrieval optimization has a ceiling: once retrieval quality passes a threshold, the dominant source of error shifts from missing knowledge to imperfect reasoning over correctly retrieved knowledge. We measured this directly — missions where retrieval is correct, the assembled context is correct, and the model is still wrong. So the runtime must optimize not only context acquisition but the reasoning strategy applied to that context. Retrieval and reasoning are orthogonal optimization problems: improving one does not guarantee improvements in the other. The runtime owns both.
A Mission is an executable business objective. It carries its goal, constraints, policies, permissions, budget, deadline, context, evidence, execution graph, state and outcome. Mission state is persisted and event-sourced: it survives failures, interruptions, restarts and model changes, and every transition is replayable and auditable.
Crucially, a mission does not own a graph directly. It references its world state and its active plan; a plan compiles to an execution graph, and a mission may hold several plan revisions over its life (re-plans on failure or new evidence).
Traditional software exposes user interfaces; agentic applications expose capabilities — customer_lookup, search_knowledge, generate_invoice, issue_refund, schedule_meeting, research_company, send_outreach, update_crm, human_approval. Internally a capability may use MCP, REST, SQL, GraphQL, an SDK, a CLI or a native integration; Mission Runtime remains implementation-agnostic and reasons over the capability graph, not over applications. Applications own implementations; capabilities stay stable, so workflows evolve independently of the technology beneath them. A capability is a metered, permissioned syscall — with cost, side-effect, undo, permission and confidence metadata the planner and cost model reason over.
Mission Runtime constructs execution graphs dynamically from the goal, policy, evidence and available capabilities, and drives them over a durable, event-sourced substrate.
The heart of the architecture is not a single "context" but a disciplined notion of state. An operator reports a result; the runtime does not treat that report as fact. State moves through four kinds, and only the last is authoritative for irreversible decisions:
World State is an event-sourced blackboard a mission executes over, rather than re-querying applications; capabilities read facts and write observations. Belief State is state estimation over those observations: sources disagree (CRM vs inbox vs a support ticket vs a human), so each fact carries a confidence and a conflict flag, and a low-confidence or conflicting input is surfaced for disambiguation instead of being silently trusted. This ties World State, Belief State, verification and deterministic execution into one architecture rather than four separate features.
Evidence is a first-class, append-only kernel primitive — the connective tissue between verification, explanation, approvals, replay and learning. It exists because those subsystems require it, not because a UI needs it. Every consequential decision records what was checked, against what, and why:
EvidenceRecord { claim, source, produced_at, freshness }
Claim { statement, subject, required_by_policy }
VerificationRequest { claim, evidence[], policy, confidence_threshold }
VerificationResult { decision, confidence, evidence[], verifier }
StateAssertion { key, expected, observed, holds }With an evidence model, verification is an auditable reasoning layer — every check answers what claim, against which evidence, from what source, how fresh, under which policy, at what confidence threshold, with what decision — rather than a scatter of boolean checks.
Verification is a runtime plane, not merely a node type. The compiler may insert explicit verification steps where checks are predictable in advance (schema validation, policy compliance, financial reconciliation, permission checks, expected-state assertions). But some verification must be dynamic — after unexpected state changes, when confidence drops, when an outcome contradicts Belief State, when a side effect succeeds technically yet fails semantically, or when cumulative evidence changes mission risk. So the runtime may invoke the Verification Plane before accepting any consequential state transition:
Status: the evidence and verification planes are implemented and tested in the reference kernel (P7) — the deterministic properties (replay, resume, audit, explain, approve) alongside verified acceptance of state transitions. Production hardening across every operator continues; the guarantee holds in-kernel today.
The project began as Knowledge → Retrieval → Answer, and Context Runtime's first contribution was to optimize the middle: Retrieval optimization → Model routing → Answer. Our benchmark evolution showed that this is only half of the problem. As retrieval improved — DIVER, HippoRAG, analytical retrieval, context-pollution removal — a residual class of failures survived every retrieval gain: retrieval correct, context correct, model still wrong. The bottleneck had moved downstream. The real pipeline is longer, and the step after context is itself an optimization target:
What the runtime learns here are execution policies, not answers. From measured outcomes — the same outcome-event loop the retrieval policy uses — it learns statements of the form: this mission class needs decomposition; that one needs chained reasoning; this model succeeds on this class and fails on another; self-verification pays off here; reasoning depth matters there; retrieval ordering changes the result. These are decisions, and the runtime makes them the way it makes every other decision — as a cost-aware, self-optimizing policy keyed by mission class, exposed in EXPLAIN, and refined as evidence accumulates.
This is the paper's central architectural claim: intelligence is not one optimizer but an optimizer hierarchy, where every stage is a learned decision with its own feedback — not a fixed pipeline stage.
This is why a better retriever is not the end of the story. Even with DIVER, HippoRAG, analytical retrieval and pollution removal, the model can still fail — so the runtime learns, for a given mission, whether it needs decomposition, chained reasoning, a self-check, a verifier, a retry, or simply a different model. Choosing among those is a runtime decision, not a prompt — which is precisely why Context Runtime exists.
How testing shaped this design (honest): several early hypotheses did not survive measurement, and the architecture above is what replaced them. A first ablation suggested hard capacity ceilings on the aggregation/temporal classes; auditing the actual questions and gold traced them to evaluation artifacts — retrieved context truncated below the gold length, and a mislabeled long-form dataset — not model capacity. So “escalate to a bigger model” was discarded in favor of a thinking pass over the full context; because that helps temporal/aggregation classes but hurts multi-hop, a global “always reason” setting was discarded in favor of a per-mission-class decision; and a code-side deterministic aggregator was discarded once full-context reasoning beat it. The durable lesson we ship: measure the policy per model and per evaluation, and audit the data before concluding a wall. The measured results that drove these choices are on the reasoning benchmark.
Planning is not a single LLM call that emits nodes. A decision engine proposes candidate execution graphs; a deterministic pipeline evaluates them before anything runs — with simulation as a first-class component of selection, not an afterthought:
Candidate plans (bounded: max count · admissible capabilities · policy-pruned branches)
↓ Policy pruning
↓ Simulation (project cost · success · latency · approvals)
↓ Cost / risk / success scoring
↓
Plan selection (prefer a non-default plan only above a confidence threshold)Exploration is bounded on purpose — a maximum candidate count and planning-latency budget, admissible-capability constraints, historical-plan reuse and a simulation budget — so plan generation stays cheap, deterministic and testable. Simulation lets the runtime choose among revisions and gate execution: a plan whose projected cost or approval count exceeds the mission budget never runs; it re-plans or escalates.
Humans remain essential execution nodes, but participation becomes policy-driven rather than workflow-driven. The runtime determines when approval is required, who should approve, what evidence to present, and when execution may safely continue. The gate decision is not a single risk × value threshold; it weighs reversibility, uncertainty, monetary value, permissions, regulatory sensitivity, novelty, blast radius, verification coverage and mission-specific policy — a low-cost but irreversible action may still require approval, while a high-value but well-verified reversible action may not. Static, mandatory capability rules are preserved as inputs (legal / contractual / organizational requirements never relax):
ApprovalDecision =
Mandatory capability rule
OR Mission policy rule
OR Dynamic risk decision
OR Verification escalationThe approver is resolved through the permissions plane, and each gate is presented as an evidence-backed approval packet: the proposed action, supporting evidence, unresolved claims, expected impact, alternatives, confidence and rollback options.
Sidekick evolves into the persistent Mission Supervisor: mission scheduling, state persistence, execution monitoring, failure recovery, approval coordination, workload balancing and progress reporting. Execution is delegated to capabilities; Sidekick supervises. The UI evolves from an execution interface into a governance interface where operators monitor progress, approve sensitive actions, adjust policies and intervene. This surface has shipped as the Mission Plane (the Projects cockpit): a mission list, an evidence-backed approval inbox, and a mission detail with the execution graph, world/belief state, event timeline and EXPLAIN.
Every completed action produces a structured Outcome Event — interview scheduled, invoice paid, customer retained, contract signed, ticket resolved. These become training data for workflow optimization, not prompt optimization. Learning operates across retrieval, planning, routing, model selection, workflow ordering, verification policies and capability selection — but each is a distinct system with its own feedback signal and safety profile, and none is allowed to mutate production behavior directly at first:
Observe → Recommend → Shadow-evaluate → Policy-constrained promotion
This keeps "self-learning" from undermining the deterministic guarantees the verification plane establishes: a policy is promoted only after it is measured off the serving path and passes the governance gate.
Mission Runtime optimizes for predictable business outcomes rather than unrestricted autonomy. Every decision can be replayed, resumed, audited, explained and approved — and, as the verification plane lands, verified. Determinism is a prerequisite for enterprise adoption: the same mission, on real cores, survives a restart, and every state transition is reconstructable from the event log.
Mission Runtime composes the ReDevOps ecosystem — Context Runtime, the Planner, ReDevOps-RAG, Sidekick, and the agentic applications (Support, Billing, Books, Outreach Engine, Growth Engine, …). Each application contributes reusable capabilities while remaining independently deployable, and because operators speak a single HTTP capability contract (/capabilities + /invoke), the fleet is polyglot: the runtime and the operators need not share a language. All fifteen agentic applications now run as operators over their real open-source cores, and cross-application missions — Revenue Rescue and New-Customer Onboarding — execute across them under policy gates, with saga compensation unwinding committed side-effects on failure or rejection.
The next release, v6 — Sidekick-driven Mission DevOps, turns this runtime into a mission DevOps operating system: the Mission Plane becomes the control plane where missions are authored (a Mission SDK), tested before promotion (Mission CI — simulate · verify · replay · regression), deployed, run and observed. Deployment itself becomes a governed mission: an infra operator wrapping Terraform (provision) and Ansible (configure), gated by human approval (a supply-chain scan gate is planned and not implemented today), and rolled back by the saga. Observability and monitoring export the mission-native evidence, timeline and world/belief state to standard telemetry and SLO dashboards.
Longer horizon: reinforcement learning over workflows, richer simulation-before-execution, multimodal and robotics nodes, digital twins, and cross-mission fair-share scheduling.
The transition from application-centric software to mission-centric computing is a new operating model for enterprise systems. Applications become operators; capabilities become reusable infrastructure; context becomes persistent, verified state; missions become the primary execution unit. Together they are the execution engine of an Agentic Runtime, and the separation is deliberate: Context Runtime remains the intelligence layer; Mission Runtime is the execution layer that orchestrates it — the objective is to complete business missions reliably, deterministically, and at scale.
An earlier version of this page said that the planned infra operator is gated by a supply-chain scan. No supply-chain scan gate is implemented today; it is planned. The deploy flow is gated by human approval. See the corrections on v6.