MRP-VM Documentation

MRP-VM is a plugin-centered recursive interpretation and resolution runtime operating over natural language and heterogeneous knowledge units. It uses a selective Controlled Natural Language (CNL) acting as a control membrane (SOP Lang Control).

The architecture is pluralistic: it supports parallel epistemic views, overlapping knowledge structures, and execution frames that form a true Directed Acyclic Graph (DAG) for parallel seed execution. Heterogeneous KUs remain rich, but their metadata is strictly controlled for rapid pruning, routing, and backtracking.

The system transforms initial problems through recursive interpretive search, deploying multiple interpretation regimes via specialized plugins, utilizing backtracking when a branch fails or becomes implausible.

Pluralistic Architecture & Selective CNL Raw Input Seed 1 (Parallel) Seed 2 (Parallel) Recursive Interpretive Search Heterogeneous Multi-View SOP Lang Control (Membrane) Backtracking on failure
Start with VM Execution Model for the kernel boundary, then read Plugin Development Guide for the concrete repository layout: src/core/**, src/plugins/<type>/<id>/**, and src/mrp-vm-sdk/**.

Architecture Vision

The Vision done

Kernel-first view of MRP-VM: the VM as an orchestration substrate rather than a hidden reasoning engine.

VM Execution Model done

Request-global budgets, execution frames, child-frame replanning, and plugin-to-plugin glue via typed stage contracts.

Execution Pipeline done

Turn lifecycle from seed bundle to grounded answer, including streaming progress and stage backtracking.

Knowledge & Retrieval done

KU-centric retrieval where built-in KB plugins own indexing, backends, and sufficiency logic.

Plugin Inventory done

Built-in plugins and their intended roles, including which DS documents define their default behavior.

External Interpreters done

Wrapper conventions for external helpers and typed plugin integration without expanding VM responsibilities.

Build Plugins

Core Engine & Pipeline done

Detailed kernel behavior: execution loop, planner retries, child frames, validation, and request timeouts.

Plugin Development Guide done

Step-by-step tutorial for `sd-plugin`, `kb-plugin`, `gs-plugin`, `mrp-plan-plugin`, and `val-plugin` authors.

Session Lifecycle done

How sessions, mounted KBs, workspace drafts, and staged KUs evolve across chat turns.

Core Concepts

CNL Formats done

Intent CNL, Context CNL, KU provenance, and phase-scoped guidance fields such as `PhaseScopes`.

Retrieval Algorithms done

Plugin-private backends for lexical, associative, and symbolic retrieval rather than VM-owned algorithms.

Plugin Types & Strategies done

The five typed plugin families and how planners route between their concrete implementations.

Meta-Rational Planning done

Adaptive plugin ordering driven by task signals, KU guidance buckets, planner hints, and historical outcomes.

Evaluation done

Planner-centric evaluation plus regression coverage for budgets, child frames, ingest safety, and chat streaming.

LLM Cache done

Disk-based LLM response caching for deterministic re-runs and zero-cost evaluation.

Future / Proposals

Agentic Loops planned

Multi-step plugin orchestration and continuation loops for complex tasks.

Symbolic Execution planned

Formal verification paths and symbolic reasoning integration.

ThinkingDB planned

Bounded symbolic closure over structured facts: multi-hop reasoning with proof-bearing ranking.