Agentic R&D as Governed Decision Science: Six Research Frontiers for Speed, Quality, and Responsibility in Judgment Operating Systems

Abstract

The central challenge of AI governance is the trilemma: speed, quality, and responsibility preservation cannot be simultaneously optimized without fundamental architectural innovation. Current governance systems choose two at the expense of the third — fast-and-responsible systems sacrifice quality, high-quality-and-fast systems erode accountability, and quality-with-responsibility systems introduce unacceptable latency. This paper argues that resolving the trilemma requires treating governance improvement as a governed research program: an Agentic R&D system where every experiment, hypothesis, and adoption decision passes through the same fail-closed gate infrastructure it seeks to optimize.

We present six mathematical research frontiers organized along the trilemma axes. For speed: (1) a Hierarchical Speculative Decision Pipeline that applies multi-layer filtering with provable false-allowance bounds, and (2) an Incremental Multi-Universe Evaluation Engine that exploits dependency graphs to achieve sub-linear re-evaluation complexity. For quality: (3) a Belief Calibration Loop with External Lag Modeling that prevents spurious causal learning in delayed-feedback environments, and (4) a Conflict-Aware Quality Improvement Loop that transforms inter-Universe contradictions from governance obstacles into quality signals. For responsibility preservation: (5) a Constrained Multi-Objective Reinforcement Learning framework operating under fail-closed shielding, and (6) a Human-in-the-Loop Reinforcement Learning system that converts approval logs into calibrated responsibility reward signals.

For each frontier, we provide formal problem statements, mathematical models with proofs or proof sketches, convergence conditions, and explicit mappings to the MARIA OS implementation. We then design the Research Universe — a first-class Universe within the MARIA coordinate system that governs its own research activities through a four-zone structure (Hypothesis, Simulation, Evaluation, Policy Sandbox) with a four-level gate policy (RG0–RG3). We present the Research Decision Graph schema, database design, event architecture, and agent team composition for four hybrid human-agent research labs. The paper concludes with a six-month research roadmap, KPI definitions, and the argument that this architecture transforms a governance product into a judgment science institution — an entity that does not merely build decision systems but advances the mathematical foundations of decision-making itself.

1. Introduction: The Governance Trilemma

Every decision system faces a fundamental trilemma. Speed — how quickly can decisions be evaluated and executed? Quality — how accurately do gates distinguish actions that should be allowed from those that should be blocked? Responsibility — when automation increases, does accountability for outcomes remain firmly attached to identifiable parties? These three objectives are not independent. They are coupled through the gate evaluation architecture, and improving one typically degrades another.

Consider the coupling mechanisms. Speed–Quality coupling: faster gate evaluation requires simpler models, which produce less accurate risk assessments. A gate that evaluates in 50ms using a heuristic filter will inevitably have higher false-allowance and false-block rates than a gate that evaluates in 2 seconds using full multi-Universe conflict analysis. Quality–Responsibility coupling: higher-quality gate decisions require richer evidence bundles and more comprehensive conflict detection, which in turn require more data access, more computation, and more complex audit trails — all of which make it harder to attribute responsibility when the gate itself makes an error. Responsibility–Speed coupling: maintaining responsibility locks requires human intervention at critical decision nodes, which introduces latency proportional to human response time.

The conventional response to a trilemma is to accept tradeoffs — choose two axes and sacrifice the third. MARIA OS rejects this compromise. The thesis of this paper is that the trilemma is resolvable, but not through incremental engineering. It requires research — mathematical investigation into the structural properties of decision evaluation, belief dynamics, conflict mechanics, and learning under governance constraints. And critically, that research must itself be governed by the same principles it investigates.

This creates a recursive structure: the governance OS uses its own governance infrastructure to govern the research that improves its governance. This is not circular reasoning. It is self-referential architecture — the same pattern that makes operating systems capable of compiling their own source code, that makes formal verification systems capable of verifying their own correctness, and that makes scientific institutions capable of studying their own methodology. The Research Universe formalized in Section 8 implements this self-referential structure concretely.

1.1 Why This Is Not Product Development

The six frontiers presented in this paper are not product features. They are research problems with open mathematical questions, convergence conditions that must be proven rather than assumed, and failure modes that must be characterized before deployment. The distinction matters because product development optimizes known architectures, while research discovers new ones. Product development can be scheduled with Gantt charts and sprint cycles. Research requires hypothesis formulation, experimental design, statistical evaluation, and the intellectual honesty to discard approaches that do not work.

The practical implication is organizational. Building these frontiers requires a research organization embedded within a product company — or, more precisely, a research Universe embedded within a governance OS. The four agent-human teams described in Section 9 are not engineering squads. They are research labs with explicit hypotheses, experimental protocols, evaluation criteria, and adoption gates.

1.2 For Engineers and Investors

This paper serves two audiences simultaneously. For engineers implementing or extending MARIA OS, it provides formal specifications for six new subsystems, including mathematical models, convergence proofs, database schemas, and API contracts. Each research frontier maps directly to implementable components with well-defined inputs, outputs, and performance targets. For investors evaluating the MARIA OS platform, it provides the theoretical moat — six research programs that require deep mathematical expertise to replicate, a self-referential architecture that compounds competitive advantage through self-improvement, and a research governance structure that prevents the catastrophic failures (runaway RL, spurious belief updates, unaudited model changes) that plague competing platforms. The combination of mathematical depth and governance discipline is, we argue, the defining characteristic of a judgment science institution.

1.3 Paper Structure

Sections 2–3 address the speed axis: hierarchical speculative pipelines (Section 2) and incremental multi-Universe evaluation (Section 3). Sections 4–5 address the quality axis: belief calibration with lag modeling (Section 4) and conflict-aware quality loops (Section 5). Sections 6–7 address the responsibility axis: constrained multi-objective RL (Section 6) and human-in-the-loop RL (Section 7). Section 8 introduces the Research Universe architecture. Section 9 details the agent team design. Section 10 presents the research roadmap and KPIs. Section 11 discusses implications for the field.

2. Research Frontier 1: Hierarchical Speculative Decision Pipeline

2.1 Problem Statement

The current MARIA gate evaluation pipeline processes every proposed action through a full multi-Universe evaluation: all N Universes are assessed, conflict scores are computed pairwise, evidence bundles are assembled, and the MAX gate function produces the final GateScore. For a system with N Universes, this requires O(N²) pairwise conflict evaluations and O(N) individual Universe assessments. As organizations scale — adding Universes for new business units, regulatory domains, or geographic regions — the evaluation latency grows quadratically in the worst case.

The research question is: Can we evaluate decisions in multiple stages, allowing provably safe actions to pass through early layers without full evaluation, while maintaining zero false-allowance guarantees?

2.2 Architecture: Three-Layer Speculative Evaluation

We propose a three-layer hierarchical pipeline inspired by speculative execution in CPU architecture, where processors begin executing instructions before knowing whether they will be needed, discarding speculative results if a branch prediction fails.

Layer 1: Fast Heuristic Filter (L₁). A lightweight approximate model classifies actions into three categories: ALLOW-candidate (high confidence of safety), BLOCK-candidate (high confidence of danger), and UNCERTAIN (requires deeper evaluation). The filter uses a reduced feature set — action category, historical risk tier, submitting agent's trust score, and basic constraint checks — to produce a preliminary classification in O(1) time.

Layer 2: Partial Universe Evaluation (L₂). For UNCERTAIN actions, L₂ evaluates only the subset of Universes most likely to be affected by the action. Universe selection uses a pre-computed affinity matrix A where A_{ij} measures the historical probability that an action in category j affects Universe i. Only Universes with A_{ij} > τ_affinity are evaluated, reducing the computation from O(N) to O(k) where k is the number of affected Universes.

Layer 3: Full Gate Evaluation (L₃). For actions that remain UNCERTAIN after L₂, or for any action where L₂ detects a potential conflict, L₃ performs the complete MAX gate evaluation across all N Universes with full evidence bundle assembly and pairwise conflict computation.

2.3 Mathematical Formalization

Let f: A → {ALLOW, BLOCK, PAUSE} be the true gate evaluation function (the full L₃ evaluation). Let h₁: A → {ALLOW-candidate, BLOCK-candidate, UNCERTAIN} be the L₁ heuristic classifier. Define the false allowance rate of the hierarchical pipeline as:

Theorem 2.1 (Speculative Safety). If the L₁ heuristic satisfies the conservative safety condition:

then FAR_hier = 0, regardless of L₂ accuracy.

Proof. The pipeline allows an action a in three cases: (1) L₁ classifies a as ALLOW-candidate and no further evaluation occurs; (2) L₁ classifies a as UNCERTAIN, L₂ evaluates and allows; or (3) L₁ classifies a as UNCERTAIN, L₂ is uncertain, L₃ evaluates and allows. In case (1), the conservative safety condition guarantees that f(a) ≠ BLOCK for any ALLOW-candidate. In cases (2) and (3), the evaluation either confirms the ALLOW or escalates to L₃, which by definition computes the true function f. Therefore, no action with f(a) = BLOCK is ever allowed. ∎

The key insight is that the safety guarantee depends only on L₁'s false-negative rate for BLOCK actions being exactly zero — that is, every action that should be blocked must either be classified as BLOCK-candidate or UNCERTAIN by L₁. L₁ is free to have a high false-positive rate (classifying safe actions as UNCERTAIN), which merely reduces speedup without compromising safety.

2.4 Optimal Universe Ordering for Latency Minimization

When L₂ evaluates a subset of Universes, the order of evaluation matters. If the first Universe evaluated reveals a blocking condition, the remaining evaluations can be skipped (early termination). We seek the ordering that minimizes expected evaluation time.

Let p_i be the probability that Universe i produces a blocking evaluation for the action's category, and let t_i be the evaluation time for Universe i. Define the expected latency under ordering σ as:

This captures the fact that Universe σ(j) is only evaluated if all preceding Universes σ(1), ..., σ(j-1) did not produce a block.

Theorem 2.2 (Optimal Evaluation Ordering). The ordering that minimizes E[T_σ] is the decreasing ratio order: sort Universes by p_i / t_i in decreasing order. That is, evaluate first the Universe with the highest probability-of-blocking per unit evaluation time.

Proof sketch. This is an instance of the weighted shortest job first scheduling problem. Consider two adjacent Universes i and j in the ordering. Swapping their order is beneficial if and only if p_i / t_i > p_j / t_j. By the adjacent swap argument, the globally optimal ordering is the one where no beneficial adjacent swap exists, which is precisely the decreasing p_i / t_i order. ∎

This result has direct implementation implications: MARIA OS can maintain a running estimate of (p_i, t_i) for each Universe and dynamically reorder L₂ evaluation based on historical performance, approaching optimal latency without manual configuration.

2.5 Heuristic Error Bounds and Fail-Closed Compatibility

The conservative safety condition (Theorem 2.1) is a hard requirement: L₁ must never classify a truly dangerous action as ALLOW-candidate. In practice, this means L₁ must be a lower bound estimator for danger — it can overestimate danger (marking safe actions as UNCERTAIN) but never underestimate it.

We formalize this through a safety margin parameter δ_safe:

where r̂(a) is L₁'s risk estimate and τ_allow is the allowing threshold. The margin δ_safe absorbs estimation error. For δ_safe ≥ max_a |r̂(a) - r(a)| (the maximum estimation error), the conservative safety condition holds. In practice, δ_safe is calibrated from historical data using conformal prediction intervals, ensuring the desired coverage probability.

The fail-closed property is preserved because: (1) L₁ BLOCK-candidates are immediately blocked without further evaluation; (2) L₁ UNCERTAIN actions are escalated to deeper evaluation; and (3) at every layer, the default action on evaluation failure (timeout, error, ambiguity) is BLOCK. The hierarchical pipeline is fail-closed at every layer, not just at L₃.

3. Research Frontier 2: Incremental Multi-Universe Evaluation Engine

3.1 Problem Statement

Full re-evaluation of all N Universes on every decision is wasteful when most Universes have not changed since the last evaluation. If only one Universe has updated its constraints, policies, or state, the remaining N-1 evaluations are redundant. The research question is: Can we exploit the dependency structure between Universes to identify the minimal re-evaluation set, reducing evaluation complexity from O(N) to O(k) where k ≪ N?

3.2 The Universe Dependency Graph

We model inter-Universe dependencies as a directed graph G = (V, E) where each vertex v_i represents Universe i and each directed edge (v_i, v_j) indicates that a change in Universe i may affect the evaluation of Universe j. The edge weight w_{ij} represents the strength of the dependency.

The dependency graph is constructed from three sources: (1) Explicit policy references — when Universe j's gate policy references a constraint defined by Universe i; (2) Historical correlation — when changes to Universe i's state have historically caused GateScore changes in Universe j (measured by conditional mutual information); and (3) Structural coupling — when Universes i and j share Planets, Zones, or Agents in the MARIA coordinate hierarchy.

3.3 Minimal Re-Evaluation Set

Given a change event in Universe i, the minimal re-evaluation set R(i) is the set of all Universes whose GateScore may change as a result. Formally:

where ε is a propagation threshold below which the influence is considered negligible. R(i) is computed via a bounded breadth-first search on G, truncating paths where the cumulative influence drops below ε.

Theorem 3.1 (Correctness of Incremental Evaluation). Let S_t be the full system state at time t, and let S_{t+1} differ from S_t only in Universe i. If the incremental evaluation re-evaluates only Universes in R(i) and reuses cached scores for Universes not in R(i), then the resulting GateScore equals the full re-evaluation GateScore up to error bounded by ε.

Proof sketch. Each Universe j ∉ R(i) has influence from Universe i bounded by ε (by construction of R(i)). The maximum individual GateScore perturbation from Universe j is ε · |ϕ_j|. Summing across at most N Universes gives the bound. For practical configurations where ε ≪ 1/N, the total error is negligible relative to the gate thresholds τ_allow and τ_block. ∎

3.4 Immutable State Snapshots

The incremental engine requires that Universe evaluations be deterministic functions of their input state. We achieve this through immutable state snapshots: at each evaluation cycle, the engine captures a versioned snapshot of each Universe's state (constraints, policies, active decisions, agent configurations). Snapshots are stored immutably, enabling cache invalidation based on snapshot version comparison.

The snapshot comparison function is O(1) per Universe: if the snapshot version of Universe j has not changed since the last evaluation, the cached GateScore contribution ϕ_j is valid. Only Universes with version increments — which, by the dependency graph, propagate to at most R(i) Universes — require re-evaluation.

3.5 Conflict Score Differential Updates

The Conflict function Conflict(a) = ⟨W, ReLU(−C)⟩ depends on the full correlation matrix C. Re-computing C from scratch requires O(N²) pairwise correlations. We derive a differential update formula for the case where only Universe i's objective series changes.

Let o_i^{new} be the updated objective series for Universe i. The updated correlation coefficients are:

This requires O(N) recomputations — one per Universe pair involving Universe i. The remaining O(N² − N) entries of C are unchanged. The updated Conflict score is:

This differential update computes Conflict in O(N) rather than O(N²), a significant improvement for large-scale multi-Universe deployments.

4. Research Frontier 3: Belief Calibration Loop with External Lag Modeling

4.1 Problem Statement

The Control and Learning dynamics (Axiom 5 of Decision Intelligence Theory) assume that observed outcomes arrive promptly after decision execution. In practice, external outcomes exhibit significant lag: a procurement decision's quality becomes apparent only when the goods arrive (weeks later), a strategic hiring decision's impact materializes over quarters, and a compliance policy's effectiveness emerges only during the next audit cycle. If the learning loop attributes outcomes to the wrong decisions due to temporal misalignment, it learns spurious causal relationships — a phenomenon we call lag-induced belief corruption.

The research question is: Can we model the lag distribution explicitly and incorporate it into Bayesian belief updates without destabilizing the governance system?

4.2 Lag Distribution Model

For each Universe U_i, we maintain a lag distribution parameter θ_i that characterizes the delay between decision execution and external outcome observation. We model the lag as a Gamma distribution:

where α_i is the shape parameter (controlling the spread of delays) and β_i is the rate parameter (controlling the mean delay). The mean lag for Universe i is E[Lag_i] = α_i / β_i and the variance is Var[Lag_i] = α_i / β_i². The Gamma distribution is chosen because it is supported on [0, ∞), is flexible enough to capture both exponential (α = 1) and peaked (α ≫ 1) delay profiles, and has a conjugate prior in the Bayesian framework.

The lag parameters θ_i = (α_i, β_i) are estimated from historical data: for each past decision in Universe i with known execution time t_exec and outcome observation time t_obs, the observed lag is δ = t_obs − t_exec. The parameters are updated via maximum likelihood estimation as new observations arrive.

4.3 Lag-Aware Bayesian Belief Update

The standard Bayesian belief update for a governance parameter ψ (e.g., a risk estimate, a gate threshold, a Universe trust score) given observation y is:

In a lagged environment, observation y_t arrives at time t but corresponds to a decision made at time t − δ, where δ is drawn from the lag distribution. The lag-aware update attributes the observation to the correct historical state:

But ψ may have drifted between t − δ and t. We model this drift as a random walk:

The lag-aware posterior at the current time t is then obtained by propagating forward:

where P(ψ_t | ψ_{t−δ}) is the transition kernel of the random walk. For Gaussian conjugate models, this integral has a closed-form solution.

4.4 Temporal Decay Weighting

To prevent ancient observations from having undue influence, we introduce an exponential decay weight:

where λ is the decay rate. Observations with large lag δ receive less weight in the posterior update. The effective evidence quality of a lagged observation is:

This decay interacts with the Control-Learning dynamics through the risk reduction term κ · g_t · q_t: when evidence quality is degraded by lag, risk reduction is slower, which the adaptive gate mechanism compensates for by increasing gate strength. The system self-corrects for lag without manual intervention.

4.5 Stability Condition: Bounded Belief Drift

The critical danger of lag-aware updates is belief runaway: if the system receives a burst of lagged observations from a period when conditions were different from the present, the posterior can shift dramatically away from the current truth. We establish a stability condition using KL-divergence bounds.

Theorem 4.1 (Bounded Belief Update). If the lag-aware update satisfies the constraint:

at every update step, then the cumulative belief drift over T steps is bounded:

Proof. By the chain rule for KL divergence and the constraint at each step, the total divergence telescopes: D_KL(P_T ‖ P_0) ≤ Σ_{t=1}^{T} D_KL(P_t ‖ P_{t-1}) ≤ T · ε_belief. ∎

The practical implementation enforces this bound by clamping the update magnitude: if a single observation would cause a KL shift exceeding ε_belief, the observation is downweighted until the constraint is satisfied. This is equivalent to a trust region method in optimization — the system takes the largest step consistent with staying within the trusted region of the posterior.

4.6 Fail-Closed Integration

The lag-aware system maintains fail-closed compatibility. When the lag distribution has high variance (uncertain delay), the temporal decay weight reduces effective evidence quality, which in turn increases the risk estimate, which triggers more conservative gate evaluations. High lag uncertainty → low evidence quality → higher GateScore → more blocking. The system naturally becomes more conservative when it is less certain about the timing of its information — exactly the behavior a governance system should exhibit.

5. Research Frontier 4: Conflict-Aware Quality Improvement Loop

5.1 Problem Statement

The Conflict function Conflict(a) = ⟨W, ReLU(−C)⟩ detects inter-Universe tension but does not resolve it. Conflict detection alone is a diagnostic tool; it tells the organization where tensions exist but not how to reduce them. The research question is: Can we use the Conflict score as an input to a quality improvement loop that systematically reduces avoidable conflicts while preserving the productive tensions that make organizations adaptive?

The distinction between avoidable and structural conflicts is critical. Some conflicts are artifacts of misaligned policies or redundant constraints that can be eliminated without loss. Others reflect genuine tradeoffs (e.g., growth vs. risk management) that should be surfaced, not suppressed. The improvement loop must distinguish between these two types.

5.2 Conflict Accumulation and Pattern Mining

The loop begins by accumulating high-conflict decisions into a conflict register CR. For each decision d with Conflict(d) > τ_conflict, the system records the contributing Universe pairs, conflict magnitudes, action categories, and outcomes:

Pattern mining over CR identifies recurrent conflict clusters — sets of Universe pairs that repeatedly produce high conflict for specific action categories. Formally, we apply frequent itemset mining over the Universe-pair dimension of CR, treating each conflict register entry as a transaction containing the conflicting Universe pairs. Itemsets with support above τ_support and lift above τ_lift are identified as conflict patterns.

5.3 Avoidable vs. Structural Conflict Classification

For each identified conflict pattern P, we classify it as avoidable or structural using a statistical test. Let Q_resolved be the set of past decisions matching pattern P that were eventually completed successfully (outcome = completed), and Q_failed be those that failed or were blocked indefinitely. The resolution rate is:

Classification rule. If ResRate(P) > τ_resolve (e.g., 0.7), the conflict pattern is classified as avoidable — the organization typically finds a way to resolve it, suggesting that the conflict is an artifact of process misalignment rather than a fundamental tradeoff. If ResRate(P) ≤ τ_resolve, the conflict is classified as structural — the organization frequently fails to resolve it, suggesting a genuine tradeoff that should be managed rather than eliminated.

5.4 Scope Split Optimization

For avoidable conflict patterns, the loop proposes scope splits: modifications to the decision space that separate conflicting concerns into independent decisions. Formally, given a decision d that triggers avoidable conflict pattern P between Universes U_i and U_j, the scope split decomposes d into sub-decisions d_i and d_j such that:

The decomposition is found by analyzing which components of d's action description contribute to each Universe's concern. If d involves both a budget allocation (primarily affecting Universe U_finance) and a staffing change (primarily affecting Universe U_hr), the scope split separates them into independent decisions, each evaluated against the relevant Universe subset.

We formalize this as an optimization problem. Let x ∈ {0, 1}^m be a binary assignment of d's m action components to sub-decision d_1 (x_k = 1) or d_2 (x_k = 0). The objective is:

For small m (typical enterprise decisions have 3–8 action components), this is solvable by enumeration. For larger m, we use a greedy heuristic that assigns each component to the sub-decision where it causes less marginal conflict.

5.5 Quality Impact Measurement

The improvement loop's effectiveness is measured by two metrics:

where FAR is the false allowance rate and FBR is the false block rate, measured over a sliding window before and after each scope split proposal is adopted. The hypothesis is that reducing avoidable conflicts reduces both FAR (fewer cases where conflicting evaluations produce ambiguous GateScores that tip toward allowing) and FBR (fewer cases where a single Universe's high concern overrides the collective assessment via the MAX operator when the concern is based on policy misalignment rather than genuine risk).

6. Research Frontier 5: Constrained Multi-Objective RL Under Fail-Closed

6.1 Problem Statement

Standard reinforcement learning maximizes expected cumulative reward. In a governance context, this is dangerous: an RL agent optimizing for decision throughput will learn to weaken gates, bypass evidence requirements, and avoid human escalation — exactly the behaviors that governance systems are designed to prevent. The research question is: Can we design an RL framework that improves decision quality while provably respecting all governance constraints, including fail-closed gates?

6.2 Constrained MDP Formulation

We formulate the problem as a Constrained Markov Decision Process (CMDP). The state space S is the MultiUniverseState — the complete state of all Universes, including current GateScores, conflict levels, evidence quality, and residual risk. The action space A is the set of policy proposals — modifications to gate thresholds, weight adjustments, evidence requirements, and escalation paths. The reward function and constraints are:

Reward:

where Δu_i(s, a) is the change in Universe i's utility (a composite of completion rate, evidence quality, and decision accuracy) when policy proposal a is applied in state s, and w_i are Universe importance weights.

Constraints:

where each C_k encodes a governance constraint: (1) GateScore violations must not increase: C_1 = ΔFalseAllowRate; (2) Responsibility Shift must remain bounded: C_2 = RS(s') − ε_RS where s' is the successor state; (3) Hard constraints must never be weakened: C_3 = max_j(ΔHardConstraintThreshold_j); (4) Gate strength must not decrease for CRITICAL risk tier: C_4 = −Δg_CRITICAL.

6.3 Lagrangian Constrained RL

We solve the CMDP using the Lagrangian relaxation approach. The Lagrangian is:

where π is the policy, λ = (λ_1, ..., λ_K) are the Lagrange multipliers (dual variables), and γ is the discount factor. The optimization alternates between:

Primal step: Maximize L(π, λ) with respect to π using standard policy gradient methods (PPO, SAC, or similar).

Dual step: Update λ to enforce constraints:

where η_λ is the dual learning rate. When constraint k is violated (E_π[C_k] > 0), the corresponding multiplier λ_k increases, penalizing the policy for future violations. When the constraint is satisfied, λ_k decreases toward zero.

6.4 Shielded RL: Pre-Filtering with Gates

As an additional safety mechanism, we propose Shielded RL: before any RL-proposed policy change is applied, it passes through the existing MARIA gate infrastructure. The gate evaluates the policy change as a decision — with the policy proposal as the action, the current MultiUniverseState as the context, and the RL agent's confidence as the evidence quality.

If the gate blocks the policy change, the RL agent receives a large negative reward signal, teaching it to avoid proposals that violate gate conditions. This creates a two-tier safety system: the Lagrangian constraints provide soft enforcement (the RL agent learns to satisfy constraints), and the gate provides hard enforcement (constraint-violating proposals are physically blocked).

Theorem 6.1 (Shield Safety). Under Shielded RL, the system never executes a policy proposal that would be blocked by the gate, regardless of the RL agent's policy. Formally: for all timesteps t and all policies π, if Gate(a_t) = BLOCK, then a_t is not applied to the system state.

Proof. The shield intercepts every action before state application. If Gate(a_t) = BLOCK, the shield substitutes a no-op action, and the state remains unchanged. The RL agent observes the blocked outcome and the penalty reward. The result follows from the fail-closed property of the gate. ∎

6.5 Sandbox Confinement

All RL training occurs exclusively in a sandbox environment — a faithful simulation of the MultiUniverseState that is physically isolated from the production decision pipeline. The sandbox maintains its own state, its own gate evaluations, and its own outcome simulations. Policy proposals that perform well in the sandbox are promoted to the Change Proposal stage (RG2 in the Research Gate Policy), where they undergo human review before any production deployment.

The sandbox is not an approximation of production. It is an exact replica of the production state at a snapshot point, evolved forward under simulated decision streams. The fidelity of the sandbox determines the transferability of learned policies. We measure sandbox fidelity using the state divergence metric:

Policies are eligible for promotion only when D_sandbox < τ_fidelity over a validation window of T timesteps.

6.6 Convergence Under Fail-Closed

A critical research question is whether the Lagrangian RL converges in a heavily constrained environment. Standard convergence guarantees for constrained RL require Slater's condition — the existence of a strictly feasible policy. In a fail-closed environment, the feasible set may be very small, and Slater's condition may barely hold.

Conjecture 6.1 (Fail-Closed Convergence). Under Shielded RL with Lagrangian constraints, if the initial policy π_0 is feasible (satisfies all constraints) and the sandbox transition dynamics are Lipschitz continuous, then the primal-dual optimization converges to a local saddle point (π, λ) within O(1/ε²) iterations.

Proving this conjecture rigorously — or identifying the conditions under which it fails — is one of the primary goals of the Safe Reinforcement Lab (Team D in Section 9). Characterizing the failure modes is as valuable as proving convergence: knowing when constrained RL does not work is essential for setting the adoption gates that prevent unsafe policies from reaching production.

7. Research Frontier 6: Human-in-the-Loop RL for Responsibility Calibration

7.1 Problem Statement

Responsibility is difficult to quantify. Unlike risk (which can be estimated from historical failure rates) or quality (which can be measured from gate accuracy), responsibility is a social construct that reflects organizational norms, legal obligations, and cultural expectations. The Responsibility Shift metric RS provides a mathematical proxy, but its parameters (I_i, R_i, h_i, g_i) must be calibrated against human judgment. The research question is: Can human approval and rejection logs serve as a reward signal for learning responsibility-preserving policies?

7.2 Human Feedback as Reward Signal

Every time a human approver reviews a decision in MARIA OS, they produce one of three outcomes: approve (the decision should proceed), modify (the decision should proceed with changes), or reject (the decision should not proceed). Each outcome encodes implicit responsibility information:

• An approve with low subsequent conflict and low post-decision risk indicates well-calibrated automation — the system correctly identified that the decision was safe for autonomous execution, and the human confirmed this assessment.
• A reject indicates that the system misjudged the decision's risk, responsibility, or quality — the governance architecture failed to catch a problem that a human detected.
• A modify indicates a partial success — the system correctly identified that the decision needed review but did not provide sufficiently refined options.

We encode these outcomes as reward signals:

where PostRisk(d) is the observed post-decision risk (measured over the lag window for the decision's Universe). The reward is modulated by conflict and post-risk: an approval that leads to high conflict or risk retrospectively reduces the reward (the human may have made a mistake), while a rejection of a high-conflict, high-risk decision provides a strong negative signal.

7.3 Trust Parameter Learning

For each Universe U_i, the RL agent maintains a policy trust parameter τ_i ∈ [0, 1] that modulates the automation level for decisions in that Universe. A trust parameter of τ_i = 1 means the system has high confidence that its policies for Universe i are well-calibrated with human judgment; τ_i = 0 means the system requires human review for every decision in Universe i.

The trust parameter is updated using exponential moving average of the reward signal:

where D_i^{(t)} is the set of decisions in Universe i during period t, and α is the learning rate. The clip function ensures that only positive rewards (approvals) contribute to trust growth — rejections reduce trust through the decay of the moving average, not through direct negative contributions. This asymmetry makes trust easier to lose than to gain, consistent with the Responsibility Lock Axiom.

7.4 Human Bias Correction

Human approvers are not infallible. They exhibit well-documented biases: availability bias (overweighting recent or memorable failures), anchoring bias (being influenced by the system's recommendation), automation bias (rubber-stamping AI proposals), and risk aversion bias (blocking decisions that are objectively safe but feel risky). If the RL system learns from biased human feedback without correction, it will amplify these biases.

We propose three bias mitigation mechanisms:

Mechanism 1: Calibration against outcomes. For each approver, the system maintains an approval accuracy score: the fraction of their approved decisions that completed successfully vs. those that failed. Approvers with consistently poor accuracy have their feedback down-weighted:

where accuracy(h) is the historical accuracy of approver h and the denominator normalizes to the population mean.

Mechanism 2: Disagreement detection. When multiple approvers review similar decisions and produce conflicting outcomes (one approves, another rejects), the system flags the disagreement rather than averaging the signals. Flagged decisions are excluded from the RL reward computation until a higher-authority approver resolves the conflict.

Mechanism 3: Few-shot learning with diverse examples. The RL agent is trained on a curated subset of decisions that spans the full range of risk tiers, categories, and outcomes, rather than on the raw approval log which may be dominated by low-risk, frequently-approved decisions. This prevents the agent from learning that approval is the default outcome.

7.5 The Responsibility Reward Hypothesis

The central research question of this frontier is: Is human approval a valid proxy for responsibility? If an approver approves a decision, does that mean the decision is responsibly governed? Or does it merely mean the approver did not have time, information, or inclination to reject it?

We formalize this as a hypothesis test. Let R_true(d) be the true responsibility quality of decision d (which we cannot directly observe) and R_proxy(d) be the approval-based proxy. The hypothesis is:

where ρ_min is the minimum acceptable correlation (e.g., 0.6). We test this hypothesis indirectly by measuring whether policy changes that increase R_proxy also decrease RS (the Responsibility Shift metric). If they do, the proxy is informative. If they do not, the proxy is contaminated by bias and must be refined.

8. The Research Universe Architecture

8.1 Design Principle: Self-Referential Governance

The Research Universe is a first-class Universe within the MARIA coordinate system that governs its own research activities using the same decision infrastructure it studies. This self-referential structure serves three purposes: (1) it provides a live test environment for the governance improvements being researched; (2) it ensures that research activities are themselves auditable, reproducible, and governed; and (3) it demonstrates to investors and regulators that the organization practices what it preaches — its internal research is governed by the same principles it sells to customers.

The Research Universe occupies a dedicated coordinate: G1.U_research. It contains four Planets (corresponding to the four research zones), each containing specialized Zones with assigned Agent teams.

8.2 Four-Zone Structure

Hypothesis Zone (P1). This zone manages the formulation, refinement, and approval of research hypotheses. Every hypothesis is a decision node: it has a risk assessment (what happens if we pursue a wrong hypothesis?), an evidence bundle (what prior work supports this hypothesis?), and a gate evaluation (is this hypothesis worth the research investment?). Agents in this zone include the Planner Agent (hypothesis decomposition), the Risk Notes Agent (failure mode analysis), and the Success Criteria Agent (measurable outcome definition).

Simulation Zone (P2). This zone executes all computational experiments in sandboxed environments. No agent in this zone has access to production systems. All data is either synthetic or anonymized. Agents include the Synthetic Data Agent (generating realistic test data), the Monte Carlo Agent (running probabilistic simulations), and the RL Trainer Agent (executing constrained RL experiments within the sandbox). Every sandbox run is recorded with full reproducibility metadata: random seed, container image hash, code commit reference, and input data fingerprint.

Evaluation Zone (P3). This zone assesses experimental results against pre-defined success criteria. Agents include the Benchmark Agent (measuring performance against baselines), the Statistical Test Agent (running hypothesis tests for significance), and the Regression Guard Agent (ensuring that improvements in one metric do not cause regressions in others). Every evaluation produces a structured artifact: the benchmark report, statistical test results, and regression analysis.

Policy Sandbox Zone (P4). This zone manages the translation of research findings into policy proposals. Unlike the Simulation Zone (which runs experiments), the Policy Sandbox Zone generates concrete proposals for production changes: modified gate thresholds, new constraint definitions, updated Universe weights. Agents include the Policy Proposer Agent (generating proposals from research findings), the Gate Verifier Agent (testing proposals against historical decisions to estimate impact), and the Rollback Designer Agent (designing safe rollback procedures in case the proposal causes unexpected behavior in production).

8.3 Research Gate Policy (RG0–RG3)

The Research Universe operates under a four-level gate policy that balances research velocity with governance integrity:

RG0: Observe. Permitted actions: read logs, generate reports, build UI mockups. No sandbox required. No human approval required. Evidence quality threshold: 0.40. This level allows researchers and agents to freely explore data and build understanding without governance overhead.

RG1: Simulate. Permitted actions: run sandbox experiments, generate synthetic data, execute Monte Carlo simulations, train RL models in sandbox. Sandbox required. No human approval required. Evidence quality threshold: 0.55. Reproducibility metadata is mandatory. Data privacy tier must not exceed P2 (sensitive). This level allows rapid experimentation within the safe confines of the sandbox.

RG2: Change Proposal. Permitted actions: propose policy changes, propose gate threshold modifications, propose pipeline restructuring. Sandbox required (proposals must be tested in sandbox before submission). Human approval required. Evidence quality threshold: 0.65. Conflict score must not exceed 0.70. Must include benchmark and report artifacts. This level is where research meets governance — every proposal is a decision that must be justified by evidence.

RG3: Adopt to Production. Permitted actions: create pull request to main branch, deploy to staging, request production rollout. Sandbox required (full regression testing). Human approval required from three mandatory reviewers: Core Systems Owner, Gate Owner, and Runtime Owner. Evidence quality threshold: 0.80. Conflict score must not exceed 0.50. Risk budget must not be exceeded. Staged rollout required. Must include benchmark, report, config, and graph artifacts. This is the highest gate level — crossing the boundary from research to production is treated as a critical governance event.

Key property. RG0 and RG1 are fast — researchers can iterate without waiting for approvals. RG2 introduces human judgment. RG3 is a ceremony — a deliberate, multi-reviewer process that ensures research findings are production-ready. This gradient provides speed where safety is assured (sandbox) and caution where consequences are irreversible (production).

8.4 Research Decision Graph

Every research track is modeled as a Decision Graph — a directed acyclic graph of decision nodes connected by conditional edges. The node types map directly to the research lifecycle:

HYPOTHESIS_NODE → DESIGN_NODE → RUN_NODE → EVALUATE_NODE → DECIDE_NODE → [ADOPT_NODE | DESIGN_NODE | END]

HYPOTHESIS_NODE: Establishes the hypothesis, success criteria, risk assessment, and scope. Gate: RG0 (observe-level evidence is sufficient to propose a hypothesis).

DESIGN_NODE: Specifies the experimental method, datasets, protocol, and evaluation plan. Gate: RG1 (the design must be simulatable in sandbox).

RUN_NODE: Executes the experiment in the sandbox. Every run is reproducible: seed, container, code reference are fixed. Gate: RG1 (sandbox execution does not require human approval, but must be recorded).

EVALUATE_NODE: Assesses results against success criteria. Must produce a benchmark artifact. Gate: RG0 (evaluation is an observational activity).

DECIDE_NODE: Determines next action: adopt the findings, redesign the experiment, discard the approach, split the scope, or change the research tier. Gate: RG2 (decisions about research direction require human input).

ADOPT_NODE: Proposes production integration. Gate: RG3 (adoption is the highest-stakes research decision).

The graph structure ensures that no research finding reaches production without passing through all intermediate stages. Shortcuts are architecturally impossible — the valid transitions are encoded in the graph schema, and the gate policy enforces the progression.

8.5 Data Architecture

The Research Universe requires five core tables:

research_programs: Immutable versioned snapshots of research program definitions (program_id, org_id, version, snapshot_json, created_at). Each modification creates a new version, preserving the complete history of how the research program evolved.

research_decision_graphs: Versioned snapshots of research decision graphs (graph_id, program_id, track_id, version, graph_json, created_at). The graph structure is data, not code — modifications to the research workflow are auditable.

sandbox_runs: Complete records of every sandbox execution (run_id, experiment_id, seed, container_ref, code_ref, status, started_at, finished_at, artifacts_json). Reproducibility is enforced at the schema level.

research_artifacts: All research outputs (artifact_id, experiment_id, kind, uri, sha256, created_at). The SHA-256 hash ensures artifact integrity. Kinds include: code, report, benchmark, ui_mock, dataset, config, graph.

gate_results: Gate evaluation records for research decisions (gate_result_id, scope_kind, scope_id, decision, gate_score, reasons_json, created_at). Every gate evaluation — including those that allow — is recorded for audit.

8.6 Event Architecture for Audit and Replay

The Research Universe emits structured events at every state transition:

• research_program_snapshot_created — a new version of the research program is recorded
• decision_node_started / decision_node_completed — lifecycle events for each graph node
• sandbox_run_started / sandbox_run_completed — sandbox execution lifecycle
• benchmark_artifact_created — a new benchmark result is available
• gate_evaluated — a gate produced a decision (allow, pause, or block)
• adoption_proposed / adoption_approved / adoption_rejected — the RG3 lifecycle

Events are the primary data structure. The tables are materialized views of the event stream. This event-sourced architecture enables complete replay: given the event log, any historical state of the Research Universe can be reconstructed exactly. This is essential for audit ("show me the state of the research program when this adoption was approved") and for debugging ("replay the experiment with this seed to verify the result").

9. Four Hybrid Agent-Human Research Teams

9.1 Design Philosophy: Structured Collaboration

Agentic R&D does not mean letting agents do research unsupervised. It means structuring research so that agents and humans collaborate within well-defined roles, with explicit handoff points, and with every interaction governed by the same decision infrastructure that governs the product. Each team is a hybrid — human researchers provide judgment, domain expertise, and creativity; agents provide computation, pattern recognition, and tireless execution of repetitive tasks.

9.2 Team A: Multi-Universe Core Lab

Research Frontiers: Incremental Multi-Universe Evaluation (Section 3) and Belief Calibration with Lag Modeling (Section 4).

Human Roles: Core Systems Engineer (owns the evaluation pipeline implementation), Gate Engineer (owns the gate policy configuration and threshold calibration).

Agent Composition:

• Research Planner Agent: Decomposes research hypotheses into testable sub-hypotheses, designs experiment sequences, identifies dependencies between experiments.
• Modeling Agent: Constructs mathematical models, derives update equations, generates convergence proofs (with human verification), implements simulation code.
• Simulation Agent: Generates synthetic multi-Universe state data, executes Monte Carlo simulations of belief update dynamics, measures convergence rates and stability margins.
• Evaluation Agent: Analyzes convergence results, estimates error bounds, compares incremental vs. full evaluation accuracy, and produces structured benchmark reports.

Deliverables: Incremental re-evaluation algorithm with correctness proof, Belief update equations with stability analysis, benchmark report comparing incremental vs. full evaluation across 10/50/100/500 Universe configurations.

9.3 Team B: Performance Acceleration Lab

Research Frontier: Hierarchical Speculative Decision Pipeline (Section 2).

Human Role: Runtime Engineer (owns the execution pipeline and latency budget).

Agent Composition:

• Pipeline Designer Agent: Designs multi-layer evaluation architectures, specifies layer boundaries and escalation conditions.
• Cost Estimator Agent: Analyzes computational cost per layer, estimates the fraction of decisions resolved at each layer under various workload distributions.
• Risk Verifier Agent: Estimates the false-allowance rate of heuristic filters, computes safety margins for the conservative safety condition (Theorem 2.1).
• Benchmark Agent: Measures end-to-end latency under realistic decision streams, compares hierarchical vs. flat evaluation performance.

Deliverables: Three-layer pipeline specification with per-layer latency targets, heuristic filter with calibrated safety margin δ_safe, latency benchmark showing ≥50% reduction with zero increase in false-allowance rate.

9.4 Team C: Conflict Intelligence Lab

Research Frontier: Conflict-Aware Quality Improvement Loop (Section 5).

Human Roles: Product Manager (owns the quality metrics and user-facing conflict resolution experience), Gate Engineer (owns the gate policy impact analysis).

Agent Composition:

• Pattern Miner Agent: Extracts conflict patterns from the conflict register, identifies recurrent Universe-pair clusters.
• Clustering Agent: Classifies conflict patterns as avoidable vs. structural using the resolution rate metric.
• Scope Split Agent: Generates scope decomposition proposals for avoidable conflicts, estimates conflict reduction from each proposal.
• Explainability Agent: Generates human-readable summaries of conflict patterns, scope split proposals, and expected quality impact for stakeholder review.

Deliverables: Conflict heatmap visualization, scope split optimization algorithm, quality impact measurement framework, UI specification for conflict resolution workflow.

9.5 Team D: Safe Reinforcement Lab (Sandbox-Only)

Research Frontiers: Constrained Multi-Objective RL (Section 6) and Human-in-the-Loop RL (Section 7).

Human Role: Research Scientist (dedicated researcher, not connected to production systems). This separation is deliberate — the researcher's only job is to understand RL convergence, characterize failure modes, and define the conditions under which learned policies are safe for production consideration.

Agent Composition:

• Environment Simulator Agent: Constructs and maintains the sandbox MultiUniverseState, generates realistic decision streams for RL training.
• Policy Learner Agent: Implements Lagrangian constrained RL and Shielded RL, trains policies in the sandbox, logs all training trajectories for reproducibility.
• Shield Agent: Implements the fail-closed gate filter that pre-screens RL proposals, measures the shield intervention rate.
• Human Feedback Agent: Processes approval logs, computes the responsibility reward signal, implements bias correction mechanisms.

Deliverables: Characterization of convergence conditions for constrained RL under fail-closed, identification of non-convergence regimes (equally valuable as convergence proofs), boundary definition for responsibility-preserving RL — the precise conditions under which learned policies maintain RS < ε.

9.6 Permission Boundaries

Permission boundaries are enforced at the architecture level, not by policy:

• Sandbox execution permissions are restricted to the Simulation Zone. No agent in any other zone can initiate a sandbox run.
• Production branch access is restricted to the Adopt Node pathway. No agent can create a PR to the main branch except through the RG3 gate.
• The Adopt Node always requires human approval. This is a hard constraint that cannot be overridden by any agent, configuration, or RL policy.
• Gate policy modifications belong to a separate Governance Universe. The Research Universe can propose gate changes (RG2) but cannot enact them — enactment requires cross-Universe governance approval.

These boundaries ensure that research cannot accidentally modify production behavior. The separation is structural, not procedural — it is enforced by the MARIA coordinate system's permission model, not by team agreements or documentation.

10. Research Roadmap and KPI Framework

10.1 Six-Month Research Timeline

Month 1. Team A begins the Incremental Multi-Universe Evaluation PoC: implement the dependency graph construction, immutable snapshot mechanism, and differential conflict score update. Team A simultaneously starts the Belief Calibration design: formalize the lag distribution model, derive the lag-aware Bayesian update equations, and establish the stability bounds.

Month 2. Team A runs stability verification on the incremental evaluation with real decision data (anonymized). Team C builds the initial conflict pattern mining pipeline and produces the first conflict heatmap visualization.

Month 3. Team B delivers the hierarchical speculative pipeline prototype. Target: demonstrate ≥50% latency reduction on a benchmark decision stream while maintaining FAR = 0. Team B begins tuning the heuristic filter safety margin.

Month 4. Team C delivers the scope split optimization algorithm and the first automated scope decomposition proposals. Team D completes the sandbox environment construction — a full MultiUniverseState replica with realistic decision stream generation.

Month 5. Team D begins constrained RL experiments. Primary goal: characterize convergence conditions. Secondary goal: identify non-convergence regimes and map them to governance configurations that make convergence impossible (these are equally valuable — they define the boundary of what RL can safely do in governance).

Month 6. Team D begins Human-in-the-Loop RL experiments using anonymized approval logs as reward signals. All four teams produce final research reports. Research reports are evaluated against adoption criteria via the RG2 gate. Findings that meet the criteria enter the RG3 adoption pipeline for production integration consideration.

10.2 KPI Definitions

Speed KPIs:

• Mean Decision Evaluation Time (MDET): Average wall-clock time from decision proposal to gate result. Target: ≥50% reduction from baseline.
• P95 Evaluation Latency: 95th percentile evaluation time. Target: P95 < 2× MDET (bounded tail latency).
• Incremental Evaluation Ratio: Fraction of decisions resolved by incremental evaluation (without full re-evaluation). Target: >80% for steady-state operations.

Quality KPIs:

• False Allowance Rate (FAR): Fraction of allowed decisions that should have been blocked. Target: 0.00% (maintained from baseline — no degradation).
• False Block Rate (FBR): Fraction of blocked decisions that should have been allowed. Target: ≥20% reduction from baseline.
• Conflict Reduction Rate: Percentage decrease in avoidable conflict patterns after scope split adoption. Target: ≥30% reduction in Conflict score for affected action categories.

Responsibility KPIs:

• Gate Bypass Rate: Fraction of decisions that circumvent gate evaluation. Target: 0.00% (absolute requirement — no exceptions, including research).
• Hard Constraint Violation Rate: Frequency of hard constraint violations reaching execution. Target: 0.00%.
• Responsibility Shift Score (RS): System-wide RS metric. Target: RS < 0.03 at all times.

Learning KPIs:

• Belief Convergence Rate: Fraction of belief update sequences that converge within the KL bound. Target: >95%.
• RL Convergence Stability: Number of training epochs to reach constraint satisfaction in sandbox. Target: characterize (no fixed target — this is a research outcome).
• Sandbox Fidelity: State divergence D_sandbox between sandbox and production over validation window. Target: D_sandbox < 0.05.

11. From Product to Institution: The Phase Transition

11.1 Why This Matters for Engineering

The six research frontiers presented in this paper are not speculative features on a product roadmap. They are well-defined mathematical problems with precise success criteria, formal convergence conditions, and explicit failure modes. Each frontier produces either a deployable improvement to the MARIA OS evaluation pipeline or a rigorous characterization of why the improvement is not possible under certain conditions. Both outcomes advance the field.

For engineers, the key takeaway is that governance system improvement is not a matter of heuristic tuning or parameter sweeping. It requires mathematical investigation — proving that incremental evaluation preserves gate correctness (Theorem 3.1), that belief updates remain stable under lag (Theorem 4.1), that speculative pipelines maintain zero false allowance (Theorem 2.1), and that constrained RL converges under fail-closed shielding (Conjecture 6.1). These are not optional academic exercises. They are safety-critical requirements for any system that governs high-impact autonomous decisions.

11.2 Why This Matters for Investors

The moat for an AI governance company is not the code — code can be replicated. The moat is the mathematical framework that the code implements and the research organization that advances that framework. The six research frontiers described in this paper represent a research program that requires deep expertise in control theory, Bayesian statistics, combinatorial optimization, constrained reinforcement learning, and causal inference. Replicating the product without replicating the research is building a shell without a foundation.

The Research Universe architecture compounds this advantage. Every research cycle that passes through the governed Decision Graph produces not only algorithmic improvements but also operational evidence that the governance system works — evidence that can be presented to regulators, auditors, and customers. A competitor would need to build both the research capability and the governance infrastructure to validate it. This dual requirement creates a barrier that grows with each research cycle.

Moreover, the self-referential structure means that the platform's research velocity accelerates over time. As the incremental evaluation engine reduces evaluation latency, research experiments complete faster. As the belief calibration loop improves evidence quality, gate decisions become more accurate. As the conflict resolution loop reduces avoidable conflicts, the research Decision Graph encounters fewer obstructions. Each improvement feeds back into the research infrastructure that produced it. This is the defining characteristic of a compound moat — it is not static but grows with investment.

11.3 The Judgment Science Institution

When a company researches its own decision-making processes using its own decision-making infrastructure, it has transcended the boundaries of product development. It has become a judgment science institution — an entity that does not merely build tools for better decisions but advances the mathematical foundations of decision-making itself.

This is the trajectory that MARIA OS is on. The six research frontiers are the first concrete steps. The Research Universe is the organizational structure that makes these steps systematic rather than ad hoc. The four agent-human research teams are the operational units that execute the research. The gate policy and Decision Graph ensure that the research is governed, auditable, and reproducible.

The governance trilemma — speed, quality, responsibility — is the central challenge. This paper has laid out the mathematical framework for addressing each axis, the organizational architecture for conducting the research, and the governance infrastructure for ensuring that the research itself meets the standards it seeks to advance. The company that solves this trilemma will not just build a better product. It will establish the science of judgment at scale.

Appendix A: Mathematical Symbol Reference

Appendix B: Research Gate Policy YAML Specification

gate_policy_id: research-gate-v1
mode: fail_closed

levels:
  - id: RG0
    name: Observe
    allowed_actions: [READ_LOGS, GENERATE_REPORT, BUILD_UI_MOCK]
    requirements:
      sandbox: false
      human_approval: false
      evidence_quality_min: 0.40

  - id: RG1
    name: Simulate
    allowed_actions: [RUN_SANDBOX, GENERATE_SYNTHETIC_DATA, RUN_MONTE_CARLO, TRAIN_RL_SANDBOX]
    requirements:
      sandbox: true
      human_approval: false
      evidence_quality_min: 0.55
      data_privacy_max: p2_sensitive
      reproducibility_required: true

  - id: RG2
    name: ChangeProposal
    allowed_actions: [PROPOSE_POLICY_CHANGE, PROPOSE_GATE_TUNING, PROPOSE_PIPELINE_LAYERING]
    requirements:
      sandbox: true
      human_approval: true
      evidence_quality_min: 0.65
      conflict_score_max: 0.70
      must_include_artifacts: [benchmark, report]

  - id: RG3
    name: AdoptToProduct
    allowed_actions: [CREATE_PR_TO_MAIN, DEPLOY_STAGING, REQUEST_PROD_ROLLOUT]
    requirements:
      sandbox: true
      human_approval: true
      evidence_quality_min: 0.80
      conflict_score_max: 0.50
      risk_over_budget_allowed: false
      staged_rollout_required: true
      must_include_artifacts: [benchmark, report, config, graph]
      mandatory_reviews: [CoreSystemsOwner, GateOwner, RuntimeOwner]

Appendix C: Database Schema (Minimal)

-- Research program snapshots (immutable versioning)
CREATE TABLE research_programs (
  program_id  TEXT NOT NULL,
  org_id      TEXT NOT NULL,
  version     INTEGER NOT NULL,
  snapshot_json JSONB NOT NULL,
  created_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
  PRIMARY KEY (program_id, version)
);

-- Research decision graphs (versioned DAGs)
CREATE TABLE research_decision_graphs (
  graph_id    TEXT NOT NULL,
  program_id  TEXT NOT NULL,
  track_id    TEXT NOT NULL,
  version     INTEGER NOT NULL,
  graph_json  JSONB NOT NULL,
  created_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
  PRIMARY KEY (graph_id, version)
);

-- Sandbox runs (reproducibility-enforced)
CREATE TABLE sandbox_runs (
  run_id        TEXT PRIMARY KEY,
  experiment_id TEXT NOT NULL,
  seed          INTEGER NOT NULL,
  container_ref TEXT NOT NULL,
  code_ref      TEXT NOT NULL,
  status        TEXT NOT NULL CHECK (status IN ('queued','running','completed','failed')),
  started_at    TIMESTAMPTZ,
  finished_at   TIMESTAMPTZ,
  artifacts_json JSONB
);

-- Research artifacts (integrity-verified)
CREATE TABLE research_artifacts (
  artifact_id   TEXT PRIMARY KEY,
  experiment_id TEXT NOT NULL,
  kind          TEXT NOT NULL CHECK (kind IN ('code','report','benchmark','ui_mock','dataset','config','graph')),
  uri           TEXT NOT NULL,
  sha256        TEXT NOT NULL,
  created_at    TIMESTAMPTZ NOT NULL DEFAULT now()
);

-- Gate results (complete evaluation audit)
CREATE TABLE gate_results (
  gate_result_id TEXT PRIMARY KEY,
  scope_kind     TEXT NOT NULL,
  scope_id       TEXT NOT NULL,
  decision       TEXT NOT NULL CHECK (decision IN ('allow','pause','block')),
  gate_score     REAL NOT NULL,
  reasons_json   JSONB NOT NULL,
  created_at     TIMESTAMPTZ NOT NULL DEFAULT now()
);

This article is part of the MARIA OS Research Series. The six research frontiers described here represent active research programs within the MARIA OS platform. Theorems with full proofs are marked as such; conjectures and proof sketches indicate open research questions. All experimental claims are based on sandbox benchmarks; production validation is pending RG3 adoption gate approval.