Multi-Universe Investment Decision Engine: Conflict-Aware Capital Allocation with Fail-Closed Portfolio Optimization

1. Introduction: The Catastrophic Failure of Single-Score Investment Evaluation

The history of investment catastrophes is, at its core, a history of compressed information. When Long-Term Capital Management collapsed in 1998, the fund's financial models scored brilliantly on expected return and Sharpe ratio while ignoring the organizational universe (counterparty concentration), the market universe (liquidity regime change), and the regulatory universe (leverage limits that existed in spirit but not in enforcement). The models were not wrong within their universe — they were catastrophically incomplete because they operated in only one universe. When Theranos attracted $700 million in venture capital, the technology universe screamed failure: no independent replication, no peer review, no regulatory submission of core claims. But the organizational universe — charismatic founder, prestigious board, narrative momentum — overwhelmed the signal. Investors who aggregated dimensions into a single 'conviction score' averaged away the very conflict that should have halted the investment.

These are not edge cases. They are the predictable consequence of an evaluation architecture that compresses multidimensional assessment into a single number. The mathematical operation of weighted averaging — score = sum(w_i s_i) — is a lossy compression. It satisfies the information-theoretic definition of lossy encoding: the original signal cannot be reconstructed from the compressed representation. Specifically, weighted averaging loses the conflict structure* between dimensions. If an investment scores 9/10 on finance and 2/10 on ethics, and another scores 5/10 on both, a 50/50 weighted average assigns both a score of 5.5. But these are fundamentally different investments — the first is a high-return ethical catastrophe waiting to happen; the second is a mediocre but stable allocation. The conflict information — the gap between 9 and 2 — is destroyed by the averaging operation.

This paper proposes an alternative architecture: evaluate investments across multiple independent universes, surface conflicts between universes as first-class governance signals, and use fail-closed gates to ensure that critical deficiencies cannot be masked by strengths in other dimensions. The architecture is grounded in five research programs that we develop in Sections 3 through 7, each producing a concrete system component:

• Multi-Universe Investment Scoring Engine (Section 3): Evaluates investments across Financial, Market, Technology, Organization, Ethics, and Regulatory universes with max_i gate evaluation. Output: Conflict-Aware Investment Engine.
• Capital Allocation under Conflict Optimization (Section 4): Simultaneous constraints — Risk Budget, Ethical Budget, Responsibility Budget — solved via Lagrangian dual decomposition. Output: Fail-Closed Portfolio Optimizer.
• Investment Drift Detection (Section 5): Measures distance between founding investment principles and current portfolio composition in a normed vector space. Output: Investment Philosophy Drift Dashboard.
• Human-Agent Co-Investment Framework (Section 6): Agent proposes, human modifies, system re-evaluates, learning loop updates. Approval logs converted to reward signals. Output: Responsibility-Calibrated Investment Loop.
• Sandbox Venture Simulation Engine (Section 7): Monte Carlo pre-commitment verification across 10,000 synthetic market scenarios. Output: Venture Simulation Universe.

1.1 Relationship to MARIA OS and the Decision Pipeline

The Multi-Universe Investment Decision Engine is not a standalone system. It is an instantiation of the MARIA OS Decision Pipeline for the investment domain. Every concept maps directly to the MARIA OS architecture:

The MARIA OS coordinate system provides the addressing scheme for all investment entities. A typical investment decision might be addressed as G1.U_F.P3.Z1.A7 — Galaxy 1 (the holding company), Financial Universe, Planet 3 (growth equity), Zone 1 (technology sector), Agent 7 (the evaluation agent). This hierarchical addressing enables responsibility tracing: when a conflict arises between the Financial Universe score and the Ethics Universe score, the system can identify exactly which agents produced the conflicting assessments, which gates were evaluated, and which human reviewers were (or were not) consulted.

1.2 The Autonomous Industrial Holding Vision

This paper is part of a larger architectural vision: the Autonomous Industrial Holding — a holding company where investment decisions, operational management, and physical-world execution are all governed by the same responsibility architecture. The holding operates across three layers:

• Capital Layer: The Investment Universe, Fail-Closed Portfolio Engine, and Drift Detection system described in this paper. This layer decides where capital flows.
• Operational Layer: The Agentic Company Blueprint (see companion paper [37]), which structures each portfolio company as a responsibility topology where human and AI agents collaborate under gate-managed governance. This layer decides how companies operate.
• Physical Layer: The Robot Judgment OS (see companion paper [38]), which extends fail-closed gates to physical-world actuators — robotic manufacturing, autonomous logistics, sensor-driven quality control. This layer decides how machines act.

The three layers are not independent. Capital allocation decisions in the Capital Layer create constraints that propagate to the Operational Layer (e.g., a portfolio company with high ethical risk scores receives tighter operational gate thresholds). Operational performance signals propagate back to the Capital Layer (e.g., a company whose organizational health metrics deteriorate triggers a drift alert). Physical execution data propagates to both higher layers (e.g., manufacturing defect rates update both the Technology Universe score and the capital reallocation model). This bidirectional propagation is what distinguishes an Autonomous Industrial Holding from a traditional conglomerate with AI tools — the governance architecture is unified across all layers, not bolted on separately at each level.

1.3 Paper Organization

Section 2 provides mathematical preliminaries and notation. Section 3 presents the Multi-Universe Investment Scoring Engine. Section 4 develops conflict-aware capital allocation. Section 5 introduces investment drift detection. Section 6 formalizes the human-agent co-investment loop. Section 7 describes the venture simulation engine. Section 8 integrates the five components into the Autonomous Industrial Holding architecture. Section 9 presents experimental design and methodology. Section 10 reports results. Section 11 discusses implications, limitations, and future directions. Section 12 concludes. Section 13 lists references.

2. Mathematical Preliminaries and Notation

We establish the formal notation used throughout this paper. Let I = {I_1, I_2, ..., I_n} denote a set of n candidate investments. Let U = {U_F, U_M, U_T, U_O, U_E, U_R} denote the six evaluation universes: Financial, Market, Technology, Organization, Ethics, and Regulatory, respectively. We use |U| = 6 throughout, although the framework generalizes to arbitrary universe sets.

Definition 2.1 (Universe Score Function). For each universe U_k in U, the universe score function s_k: I -> [0, 1] maps each investment to a normalized score in the unit interval, where 0 represents complete failure in universe k and 1 represents ideal performance. The score function s_k encapsulates all evaluation criteria specific to universe k — financial metrics for U_F, market positioning for U_M, technology maturity for U_T, organizational health for U_O, ethical alignment for U_E, and regulatory compliance for U_R.

$ s_k(I_j) in [0, 1], for all I_j in I, for all U_k in U

Definition 2.2 (Investment Score Vector). The investment score vector for investment I_j is the |U|-dimensional vector:

$ S(I_j) = (s_F(I_j), s_M(I_j), s_T(I_j), s_O(I_j), s_E(I_j), s_R(I_j)) in [0, 1]^6

This vector lives in the six-dimensional unit hypercube. Traditional evaluation projects this vector onto a scalar via weighted averaging. Our framework preserves the full vector and operates on it geometrically.

Definition 2.3 (Gate Threshold Vector). The gate threshold vector tau = (tau_F, tau_M, tau_T, tau_O, tau_E, tau_R) in [0, 1]^6 specifies the minimum acceptable score in each universe. An investment must meet or exceed the threshold in every universe to pass the gate.

Definition 2.4 (Conflict Matrix). For a portfolio P = {I_1, ..., I_m} of m investments, the conflict matrix C in R^{6 x 6} has entries:

$ C_{kl} = Corr(s_k(P), s_l(P)) = Cov(s_k, s_l) / (sigma_k * sigma_l) (Conflict Matrix)

where s_k(P) = (s_k(I_1), ..., s_k(I_m)) is the vector of universe-k scores across all portfolio investments. Negative entries C_{kl} < 0 indicate systematic conflict between universes k and l: investments that score well in universe k tend to score poorly in universe l.

Definition 2.5 (Capital Allocation Vector). The capital allocation vector x = (x_1, x_2, ..., x_n) in R^n specifies the fraction of total capital allocated to each candidate investment, subject to sum(x_j) = 1 and x_j >= 0 for all j.

Definition 2.6 (MARIA Coordinate for Investment Entities). Within the MARIA OS hierarchy, investment entities are addressed as G(galaxy).U(universe).P(planet).Z(zone).A(agent). For the investment domain:

• Galaxy G: the holding company or fund entity
• Universe U: one of {U_F, U_M, U_T, U_O, U_E, U_R} evaluation dimensions
• Planet P: asset class or investment strategy (e.g., P1 = venture, P2 = growth equity, P3 = buyout)
• Zone Z: sector or geographic focus
• Agent A: individual evaluation agent or human analyst

We use lowercase bold for vectors (e.g., x, s, tau), uppercase bold for matrices (e.g., C, W), calligraphic for sets (e.g., I, U, P), and standard mathematical notation for functions and operators.

3. Multi-Universe Investment Scoring Engine

3.1 The Failure of Weighted Averaging

The standard practice in investment evaluation is to assign weights to evaluation criteria and compute a weighted sum. Let w = (w_1, ..., w_6) with sum(w_k) = 1 be a weight vector. The traditional composite score is:

$ Score_traditional(I_j) = sum_{k=1}^{6} w_k * s_k(I_j) (Traditional Weighted Average)

This operation is a linear projection from R^6 to R. It preserves no information about the distribution of scores across universes. Two investments with identical composite scores can have radically different risk profiles:

Alpha Corp is a high-return, high-conflict investment: exceptional on financial and market dimensions, catastrophic on ethics and regulatory. Beta Corp is a uniform, conflict-free investment: mediocre everywhere but dangerous nowhere. The weighted average assigns them identical scores. A fund that allocates capital based on this score treats them as interchangeable — a decision that would likely end in regulatory enforcement action or reputational damage when Alpha Corp's ethical deficiencies materialize.

3.2 max_i Gate Evaluation

The MARIA OS framework replaces weighted averaging with max_i gate evaluation: the investment's gate score is determined by its worst-performing universe relative to its threshold, not by the average.

Definition 3.1 (Gate Deficit). The gate deficit for investment I_j in universe U_k is:

$ delta_k(I_j) = max(0, tau_k - s_k(I_j)) (Gate Deficit)

The deficit is zero when the investment meets or exceeds the threshold, and positive when it falls short. It measures the magnitude of failure in a specific universe.

Definition 3.2 (Multi-Universe Gate Score). The Multi-Universe Gate Score for investment I_j is:

$ GateScore(I_j) = max_{k in {F,M,T,O,E,R}} delta_k(I_j) (Multi-Universe Gate Score)

The gate score equals the largest deficit across all universes. If GateScore(I_j) = 0, the investment passes all gates. If GateScore(I_j) > 0, at least one universe has a critical deficiency, and the magnitude indicates the severity of the worst violation.

Definition 3.3 (Gate Decision Function). The gate decision for investment I_j is:

$ Decision(I_j) = BLOCK if GateScore(I_j) > 0; PASS if GateScore(I_j) = 0 (Fail-Closed Gate Decision)

This is a fail-closed design: any single universe failure blocks the investment. There is no mechanism for a high score in one universe to compensate for a low score in another. This is the fundamental departure from weighted averaging.

Theorem 3.1 (Zero False Allowance under Single-Universe Violation). If there exists any universe U_k such that s_k(I_j) < tau_k, then Decision(I_j) = BLOCK. No investment with a below-threshold score in any universe can pass the gate.

Proof. If s_k(I_j) < tau_k for some k, then delta_k(I_j) = tau_k - s_k(I_j) > 0. Therefore GateScore(I_j) = max_k delta_k(I_j) >= delta_k(I_j) > 0. By Definition 3.3, Decision(I_j) = BLOCK. QED.

This theorem is trivial by construction, but its implications are profound. It means that no amount of financial excellence can override ethical failure. No amount of market opportunity can override regulatory non-compliance. The gate architecture encodes the principle that certain evaluation dimensions are non-negotiable — they must be individually satisfied, not collectively averaged.

3.3 Conflict Surface Detection

Beyond individual investment evaluation, the Multi-Universe engine detects systematic conflicts in the portfolio's score distribution. Recall the conflict matrix C from Definition 2.4.

Definition 3.4 (Universe Conflict Indicator). Universes U_k and U_l are in systematic conflict within portfolio P if:

$ C_{kl} < -epsilon_C (Conflict Threshold)

where epsilon_C > 0 is a configurable conflict sensitivity threshold. A negative correlation between universe scores means that the portfolio systematically sacrifices performance in one dimension to achieve performance in another.

Proposition 3.1 (Conflict implies Non-Dominated Trade-off). If C_{kl} < -epsilon_C for universes U_k and U_l, then for any portfolio reallocating capital to improve the aggregate score in universe k, the aggregate score in universe l decreases, and vice versa. The portfolio lies on the Pareto frontier of the (s_k, s_l) trade-off surface.

Proof. Negative correlation between s_k(P) and s_l(P) implies that investments with high s_k scores tend to have low s_l scores. Increasing allocation x_j for high-s_k investments mechanically increases the portfolio's weighted average in universe k while decreasing it in universe l, because the same investments that contribute positively to the k-weighted sum contribute negatively to the l-weighted sum. Formally, let s_k(P) = sum(x_j s_k(I_j)) and s_l(P) = sum(x_j s_l(I_j)). The gradient of s_k(P) with respect to x is the vector (s_k(I_1), ..., s_k(I_n)), and similarly for s_l(P). When C_{kl} < 0, these gradient vectors have negative inner product: sum(s_k(I_j) s_l(I_j)) < (1/n) sum(s_k(I_j)) * sum(s_l(I_j)). This means any allocation change that increases s_k(P) tends to decrease s_l(P), confirming that the portfolio is on the Pareto frontier of the two-universe trade-off. QED.

3.4 Conflict Cards and Escalation

When the engine detects systematic conflict (C_{kl} < -epsilon_C), it generates a Conflict Card — a structured governance artifact that surfaces the conflict to human decision-makers. The Conflict Card contains:

• The conflicting universe pair (U_k, U_l)
• The correlation coefficient C_{kl}
• The set of investments driving the conflict (those with above-median s_k and below-median s_l, or vice versa)
• A recommended resolution action: ACCEPT (acknowledge trade-off), REBALANCE (adjust allocation), or ESCALATE (human committee review)
• The MARIA OS coordinates of all agents involved in scoring the conflicting universes

Conflict Cards flow through the MARIA OS Decision Pipeline as governance events. In the fail-closed architecture, unresolved Conflict Cards with |C_{kl}| above a severity threshold block portfolio rebalancing until a human with appropriate authority reviews and resolves the conflict. This ensures that systematic trade-offs are explicit governance decisions, not implicit artifacts of optimization.

3.5 Computational Complexity

For n candidate investments and |U| = 6 universes, the Multi-Universe Gate Score computation requires O(n |U|) time — linear in portfolio size. The conflict matrix computation requires O(n |U|^2) time for the pairwise correlations. Since |U| is fixed at 6, both operations are O(n) in practice. This is critical for real-time portfolio monitoring: the engine can re-evaluate the entire portfolio on every market data update without computational bottleneck.

4. Capital Allocation under Conflict Optimization

4.1 The Three-Budget Constraint Framework

Traditional portfolio optimization operates under a single constraint: the risk budget. Markowitz mean-variance optimization [1] minimizes portfolio variance subject to a target return. The Capital Asset Pricing Model [2] prices assets relative to systematic risk. Even modern risk parity and Black-Litterman models [3] operate within a single risk dimension.

The Multi-Universe framework introduces two additional constraint dimensions that must be satisfied simultaneously:

• Risk Budget (B_R): The maximum acceptable portfolio-level risk, measured as the expected maximum gate deficit across all universes. This generalizes traditional Value-at-Risk to multi-universe evaluation.
• Ethical Budget (B_E): The maximum acceptable aggregate ethical deficit across the portfolio. This enforces the fund's ethical mandate as a hard constraint, not a soft preference.
• Responsibility Budget (B_Resp): The maximum acceptable fraction of capital allocated to investments where the gate decision was made by agents without human review. This ensures that a configurable minimum fraction of capital allocation has human-in-the-loop oversight.

Definition 4.1 (Portfolio Risk Measure). The portfolio risk measure under Multi-Universe evaluation is:

$ Rho(x) = E[max_{k} sum_{j=1}^{n} x_j * delta_k(I_j)] (Portfolio Risk Measure)

This measures the expected worst-universe aggregate deficit across the portfolio. It is not a variance-based measure — it captures tail risk in the worst-performing dimension, which is precisely the risk that weighted averaging obscures.

Definition 4.2 (Portfolio Ethical Deficit). The portfolio ethical deficit is:

$ Eta(x) = sum_{j=1}^{n} x_j * delta_E(I_j) (Ethical Deficit)

where delta_E(I_j) = max(0, tau_E - s_E(I_j)) is the ethics universe gate deficit. This aggregates ethical shortfalls across the portfolio, weighted by capital allocation.

Definition 4.3 (Responsibility Exposure). The responsibility exposure is:

$ Psi(x) = sum_{j: Decision(I_j) was agent-only} x_j (Responsibility Exposure)

This measures the fraction of capital allocated to investments where the gate decision was made entirely by AI agents without human review. The Responsibility Budget constrains this to ensure sufficient human oversight.

4.2 The Conflict-Aware Optimization Problem

The Fail-Closed Portfolio Optimizer solves the following constrained optimization problem:

$ maximize_{x} sum_{j=1}^{n} x_j * mu_j subject to: Rho(x) <= B_R (Risk Budget) Eta(x) <= B_E (Ethical Budget) Psi(x) <= B_Resp (Responsibility Budget) sum_{j} x_j = 1, x_j >= 0 for all j (Conflict-Aware Portfolio Optimization)

where mu_j is the expected return of investment I_j. The objective maximizes expected portfolio return subject to three simultaneous constraints. The critical difference from Markowitz optimization is that the constraints are heterogeneous — risk, ethics, and responsibility are measured in different units and enforced by different mechanisms — and they are fail-closed: violation of any single constraint blocks the allocation.

4.3 Lagrangian Dual Decomposition

We solve the optimization problem via Lagrangian dual decomposition. The Lagrangian is:

$ L(x, lambda, nu, xi) = sum_j x_j mu_j - lambda (Rho(x) - B_R) - nu (Eta(x) - B_E) - xi (Psi(x) - B_Resp) (Lagrangian)

where lambda >= 0, nu >= 0, and xi >= 0 are the Lagrange multipliers for the risk, ethical, and responsibility constraints, respectively. The dual function is:

$ g(lambda, nu, xi) = max_{x in Delta} L(x, lambda, nu, xi) (Dual Function)

where Delta = {x in R^n : sum(x_j) = 1, x_j >= 0} is the probability simplex.

Theorem 4.1 (Strong Duality for Conflict-Aware Allocation). The conflict-aware portfolio optimization problem satisfies strong duality: the optimal value of the primal problem equals the optimal value of the dual problem. Furthermore, the optimal multipliers (lambda, nu, xi*) have economic interpretations as the marginal cost of tightening each budget constraint.

Proof. The primal problem is a linear program (LP) when Rho, Eta, and Psi are linear in x. The expected return sum(x_j mu_j) is linear. The ethical deficit Eta(x) = sum(x_j delta_E(I_j)) is linear. The responsibility exposure Psi(x) = sum_{j in A} x_j (where A is the set of agent-only decisions) is linear. The risk measure Rho(x) = E[max_k sum_j x_j delta_k(I_j)] is the expectation of a maximum of linear functions — this is convex in x (since the maximum of affine functions is convex and expectation preserves convexity). Therefore the feasible region is the intersection of a convex set (Rho(x) <= B_R) with linear constraints, and the objective is linear. By Slater's constraint qualification, strong duality holds if there exists a strictly feasible point x_0 with Rho(x_0) < B_R, Eta(x_0) < B_E, and Psi(x_0) < B_Resp. Such a point exists whenever the investment set I contains at least one investment that passes all gates with margin (i.e., s_k(I_j) > tau_k + epsilon for all k), which we assume as a non-degeneracy condition. Under strong duality, the optimal multiplier lambda equals the marginal value of relaxing the risk budget: d(optimal return)/d(B_R) = lambda. Similarly, nu = d(return)/d(B_E) and xi* = d(return)/d(B_Resp). These multipliers quantify the economic cost of governance constraints, enabling principled trade-off analysis. QED.

4.4 Dual Decomposition Algorithm

The dual problem decomposes into n independent subproblems, one per investment. For fixed multipliers (lambda, nu, xi), the optimal allocation to investment j is determined by the adjusted return:

$ mu_j^adj = mu_j - lambda partial Rho / partial x_j - nu delta_E(I_j) - xi * 1_{j in A} (Adjusted Return)

where partial Rho / partial x_j is the marginal contribution of investment j to portfolio risk, delta_E(I_j) is the ethical deficit of investment j, and 1_{j in A} is the indicator that investment j was agent-evaluated without human review.

The algorithm alternates between: (1) computing optimal allocation x*(lambda, nu, xi) for current multipliers by allocating to the investment with highest adjusted return, and (2) updating multipliers via subgradient ascent:

$ lambda^{t+1} = max(0, lambda^t + alpha_t (Rho(x^t) - B_R)) $ nu^{t+1} = max(0, nu^t + alpha_t (Eta(x^t) - B_E)) $ xi^{t+1} = max(0, xi^t + alpha_t * (Psi(x^t) - B_Resp)) (Subgradient Update)

where alpha_t is the step size at iteration t. With diminishing step sizes (alpha_t = c / sqrt(t) for some constant c > 0), subgradient ascent converges to the optimal dual value [4].

Theorem 4.2 (Convergence of Dual Decomposition). The dual decomposition algorithm converges to the optimal allocation x* within epsilon of the optimal return value after at most O(1/epsilon^2) iterations.

Proof. This follows from the standard convergence result for subgradient methods on convex dual problems. The dual function g(lambda, nu, xi) is concave (as the pointwise minimum of affine functions of the multipliers). The subgradients are bounded because Rho, Eta, and Psi are all bounded on the simplex Delta (they are continuous functions on a compact set). With step size alpha_t = c / sqrt(t), the classical result of Polyak [5] and Shor [6] gives convergence of the best dual value g_best^T = max_{t<=T} g(lambda^t, nu^t, xi^t) to g* = max g within O(1/sqrt(T)) error, requiring T = O(1/epsilon^2) iterations for epsilon-optimality. Since strong duality holds (Theorem 4.1), convergence of the dual also implies convergence of the primal. QED.

4.5 Economic Interpretation of Multipliers

The optimal Lagrange multipliers provide quantitative answers to governance questions that are traditionally resolved by committee debate:

• lambda (risk price)*: How much expected return does the fund sacrifice per unit of risk budget tightening? If lambda = 0.12, then reducing the risk budget by one unit costs 12 basis points of expected return.
• nu (ethics price)*: How much expected return does the fund sacrifice per unit of ethical budget tightening? If nu = 0.08, then the fund's ethical mandate costs 8 basis points per unit — a precise, auditable cost of ethical governance.
• xi (responsibility price)*: How much expected return does the fund sacrifice to require human review of additional investments? If xi = 0.05, then each percentage point of additional human oversight costs 5 basis points — quantifying the speed-versus-governance trade-off.

These multipliers transform governance debates from qualitative arguments ('we should be more ethical') into quantitative trade-off analysis ('increasing our ethical constraint by one standard deviation costs 8 basis points of expected return; here is the evidence from the Lagrangian'). The MARIA OS Decision Pipeline surfaces these multipliers in the fund's governance dashboard as real-time metrics.

5. Investment Drift Detection

5.1 The Problem of Style Drift

Every investment fund begins with a founding philosophy: a set of principles that define what the fund invests in, why, and under what constraints. A venture fund might commit to 'deep tech with defensible IP.' A growth equity fund might commit to 'profitable SaaS with net revenue retention above 120%.' An impact fund might commit to 'climate technology that meets our ESG scorecard.' Over time, the actual portfolio can drift from these founding principles — gradually at first, then suddenly, until the portfolio bears little resemblance to the stated mandate. This is investment philosophy drift, and it is the capital allocation analogue of technical debt: invisible in the short term, catastrophic in the long term.

Traditional drift detection is manual: periodic reviews by the investment committee, annual audits, LP advisory board meetings. These mechanisms are slow (quarterly at best), subjective (based on committee members' judgment), and incomplete (they review individual deals, not the portfolio's aggregate position in philosophy space). The result is that drift accumulates undetected until it manifests as a crisis: LP redemption requests, regulatory inquiries, or public scandals when the fund's actual investments contradict its stated values.

5.2 Formalizing Investment Philosophy

We formalize an investment philosophy as a point in a normed vector space. The key insight is that a philosophy is not a single constraint but a distribution over universe scores — it specifies not just minimum thresholds but the relative emphasis across evaluation dimensions.

Definition 5.1 (Investment Philosophy Vector). An investment philosophy Phi is a vector in R^6 specifying the target score distribution across universes:

$ Phi = (phi_F, phi_M, phi_T, phi_O, phi_E, phi_R) in [0, 1]^6 (Investment Philosophy Vector)

where phi_k represents the fund's target emphasis on universe k. For example, a deep-tech venture fund might have Phi = (0.60, 0.50, 0.95, 0.70, 0.75, 0.80), indicating very high technology emphasis, moderate market requirements, and strong ethical and regulatory expectations.

Definition 5.2 (Portfolio Position Vector). The portfolio position vector Pi(x) is the capital-weighted average of investment score vectors:

$ Pi(x) = sum_{j=1}^{n} x_j S(I_j) = (sum_j x_j s_F(I_j), ..., sum_j x_j * s_R(I_j)) in [0, 1]^6 (Portfolio Position Vector)

This represents the portfolio's actual position in philosophy space — where the capital is actually deployed across the six evaluation dimensions.

5.3 The Drift Index

Definition 5.3 (Investment Philosophy Drift Index). The drift index D(x, Phi) measures the distance between the portfolio's actual position and the fund's stated philosophy:

$ D(x, Phi) = || W (Pi(x) - Phi) ||_2 = sqrt(sum_{k=1}^{6} w_k^2 (Pi_k(x) - phi_k)^2) (Drift Index)

where W = diag(w_1, ..., w_6) is a diagonal weighting matrix that allows the fund to specify which dimensions of drift matter most. If ethical alignment is more important than market positioning for the fund's mandate, the weight w_E would be larger than w_M.

Proposition 5.1 (Drift Index Properties). The Drift Index D(x, Phi) satisfies: (i) D >= 0, with D = 0 if and only if Pi(x) = Phi (zero drift when portfolio matches philosophy). (ii) D is convex in x (the portfolio allocation), enabling efficient minimization. (iii) D is continuous in both x and Phi, so small changes in allocation or philosophy produce small changes in drift.

Proof. (i) follows from the norm property: ||v|| >= 0 with equality iff v = 0. (ii) Pi(x) is linear in x, so W * (Pi(x) - Phi) is affine in x, and the L2 norm of an affine function is convex. (iii) the composition of a continuous affine map and a norm is continuous. QED.

5.4 Drift Decomposition

The aggregate drift index D provides a single alarm signal, but for governance purposes the fund needs to know which dimensions are drifting. We decompose drift into per-universe components:

Definition 5.4 (Universe Drift Component). The drift component in universe k is:

$ D_k(x, Phi) = w_k * |Pi_k(x) - phi_k| (Universe Drift Component)

The total drift satisfies D^2 = sum(D_k^2) by the Pythagorean decomposition in the weighted norm. The fund's Investment Philosophy Drift Dashboard displays these components as a radar chart — a six-axis visualization where each axis represents a universe and the distance from center represents drift magnitude. The charter philosophy Phi appears as one polygon; the current portfolio position Pi(x) appears as another. The visual gap between them is drift.

5.5 Drift Velocity and Acceleration

For time-series monitoring, we define drift dynamics. Let x(t) denote the portfolio allocation at time t.

Definition 5.5 (Drift Velocity). The drift velocity is the time derivative of the drift index:

$ dD/dt = (1/D) sum_{k=1}^{6} w_k^2 (Pi_k(x(t)) - phi_k) * (d Pi_k / dt) (Drift Velocity)

Positive drift velocity indicates the portfolio is moving further from its founding philosophy; negative velocity indicates convergence back toward the mandate. The drift acceleration d^2D/dt^2 indicates whether drift is accelerating or decelerating.

Theorem 5.1 (Drift Early Warning). If drift velocity dD/dt > 0 for T_alert consecutive reporting periods, the expected time to reach the critical drift threshold D_crit is bounded by:

$ t_breach <= (D_crit - D(t_0)) / min_{t in [t_0, t_0+T_alert]} (dD/dt) (Drift Breach Time Bound)

Proof. If dD/dt >= v_min > 0 over the interval [t_0, t_0 + T_alert], then D(t) >= D(t_0) + v_min * (t - t_0) by integration. Setting D(t_breach) = D_crit and solving gives t_breach - t_0 <= (D_crit - D(t_0)) / v_min. Since v_min = min(dD/dt) over the observed interval, this is a conservative upper bound that becomes tighter as drift velocity stabilizes. QED.

This theorem provides a quantitative early warning: the Investment Philosophy Drift Dashboard displays not just the current drift level but the estimated time to breach the critical threshold, assuming current drift dynamics persist. This gives the investment committee actionable lead time to intervene.

5.6 Drift-Constrained Rebalancing

We extend the portfolio optimization problem from Section 4 with a drift constraint:

$ maximize_{x} sum_j x_j * mu_j subject to: Rho(x) <= B_R, Eta(x) <= B_E, Psi(x) <= B_Resp D(x, Phi) <= D_max sum_j x_j = 1, x_j >= 0 (Drift-Constrained Optimization)

The additional drift constraint D(x, Phi) <= D_max ensures that the optimized portfolio remains within D_max distance of the fund's founding philosophy. Since D is convex in x (Proposition 5.1), this constraint preserves the convexity of the feasible region, and the Lagrangian framework from Section 4 extends naturally with an additional multiplier gamma >= 0 for the drift constraint. The multiplier gamma* has the economic interpretation of the marginal return cost of philosophy adherence — how much expected return the fund sacrifices per unit of drift reduction.

6. Human-Agent Co-Investment Framework

6.1 The Proposal-Review-Learn Loop

In the Autonomous Industrial Holding, investment decisions are not made by humans alone or agents alone — they emerge from a structured interaction loop. The AI evaluation agent proposes; the human investment committee reviews; the system re-evaluates incorporating the human's modifications; and the learning module updates the agent's model based on the outcome. This is not a suggestion box — it is a responsibility-calibrated feedback loop where the allocation of decision authority between humans and agents adapts over time based on demonstrated performance.

The loop has four stages:

• Propose: The AI agent evaluates a candidate investment across all six universes, computes the Multi-Universe Gate Score, generates Conflict Cards for any inter-universe conflicts, and produces a structured investment recommendation with allocation amount, rationale, and risk factors.
• Review: A human investment committee member reviews the proposal. They may approve as-is, modify the allocation amount, override specific universe scores based on private information, add conditions (e.g., 'approved contingent on regulatory clearance'), or reject with documented reasoning.
• Re-evaluate: The system incorporates the human's modifications and re-runs the gate evaluation. If the modified proposal passes all gates, it enters the execution pipeline. If the human's modifications introduce new gate violations (e.g., increasing allocation to a conflicted investment), the system surfaces this conflict and requests resolution.
• Learn: The system records the human's decision as a labeled training signal. Approvals are positive signals; rejections are negative signals; modifications are correction signals that indicate the direction and magnitude of the agent's error.

6.2 Reward Signal Formalization

We formalize the human's decision as a reward signal for the agent's proposal policy. Let pi(I, C) denote the agent's proposal policy: given investment I and context C (market conditions, portfolio state, historical performance), the policy produces a recommendation r = (x_proposed, rationale, risk_flags).

Definition 6.1 (Approval Reward Signal). The reward signal from human decision d on agent proposal r for investment I is:

$ R(r, d) = +1 * (1 - |x_approved - x_proposed| / x_proposed) if d = APPROVE or MODIFY = -1 if d = REJECT = -0.5 if d = ESCALATE (human defers to committee) (Approval Reward Signal)

For approved proposals, the reward is proportional to how close the agent's proposed allocation was to the human's approved allocation. A perfect match (x_approved = x_proposed) gives reward +1. A 50% modification (x_approved = 0.5 * x_proposed) gives reward +0.5. Rejections give reward -1. Escalations give -0.5 (the agent should have recognized the need for committee review rather than proposing unilaterally).

6.3 Responsibility-Calibrated Autonomy

The key innovation in the co-investment framework is that the agent's autonomy level — how much capital it can allocate without human review — adapts based on its accumulated reward history.

Definition 6.2 (Agent Competence Score). The agent's competence score at time t is the exponentially weighted average of historical rewards:

$ K(t) = (1 - beta) sum_{i=1}^{t} beta^{t-i} R(r_i, d_i) (Agent Competence Score)

where beta in (0, 1) is the discount factor (typically beta = 0.95, giving a half-life of approximately 14 decisions).

Definition 6.3 (Autonomy Threshold Function). The agent's autonomy threshold — the maximum allocation amount it can make without human review — is:

$ A(t) = A_min + (A_max - A_min) * sigma(K(t) - K_threshold) (Autonomy Threshold)

where sigma is the sigmoid function, A_min is the minimum autonomy (e.g., $0 — no autonomous allocation), A_max is the maximum autonomy (e.g., $1M per deal), and K_threshold is the competence score required for half-maximum autonomy.

Theorem 6.1 (Monotonic Autonomy under Consistent Performance). If the agent's reward signals satisfy R(r_i, d_i) >= R_min > K_threshold for all i >= t_0, then A(t) is monotonically non-decreasing for t > t_0 and converges to A_max.

Proof. If R_i >= R_min for all i >= t_0, then for t > t_0: K(t) = (1-beta) sum_{i=1}^{t} beta^{t-i} R_i. We separate the sum into pre-t_0 and post-t_0 terms. The pre-t_0 terms decay exponentially: their contribution is bounded by beta^{t-t_0} K(t_0), which vanishes as t grows. The post-t_0 terms satisfy: (1-beta) sum_{i=t_0+1}^{t} beta^{t-i} R_i >= (1-beta) R_min sum_{i=t_0+1}^{t} beta^{t-i} = R_min (1 - beta^{t-t_0}). As t -> infinity, this approaches R_min > K_threshold, so K(t) -> R_min. Since sigma is monotonically increasing, A(t) = A_min + (A_max - A_min) sigma(K(t) - K_threshold) is also monotonically increasing for sufficiently large t, and converges to A_min + (A_max - A_min) sigma(R_min - K_threshold). If R_min is sufficiently large, A(t) -> A_max. QED.

This theorem has a governance interpretation: agents that consistently receive positive feedback from human reviewers are gradually granted more autonomy. Agents that receive negative feedback see their autonomy contract. This is graduated autonomy — a core MARIA OS principle — applied to the investment domain.

6.4 Learning from Modifications

Rejections and approvals provide binary signals. Modifications — cases where the human adjusts the agent's proposal rather than accepting or rejecting outright — provide richer information. We formalize modification learning as follows.

Definition 6.4 (Modification Gradient). When a human modifies the agent's proposal from x_proposed to x_approved, the modification gradient is:

$ nabla_mod = (x_approved - x_proposed) / x_proposed (Modification Gradient)

This is a signed scalar indicating the direction and magnitude of correction. If nabla_mod > 0, the human increased the allocation (the agent was too conservative). If nabla_mod < 0, the human decreased it (the agent was too aggressive). The magnitude indicates confidence in the correction.

The agent's policy gradient update incorporates this signal:

$ theta^{t+1} = theta^t + eta nabla_mod nabla_theta log pi(x_proposed | I, C; theta^t) (Policy Gradient Update)

where theta are the policy parameters, eta is the learning rate, and nabla_theta log pi is the score function gradient from REINFORCE [7]. This update nudges the policy toward producing proposals closer to the human's preferred allocation. Over many decisions, the agent learns not just which investments to propose but the appropriate allocation magnitude — calibrating its confidence to match the human committee's risk appetite.

6.5 Convergence Guarantees

Theorem 6.2 (Co-Investment Loop Convergence). Under stationary market conditions and consistent human preferences, the expected modification magnitude E[|nabla_mod|] converges to zero, meaning the agent's proposals converge to the human committee's preferred allocations.

Proof sketch. The modification gradient nabla_mod provides an unbiased estimate of the direction toward the human's preferred allocation. The policy gradient update with diminishing learning rate eta_t = c / sqrt(t) satisfies the Robbins-Monro conditions [8]: sum(eta_t) = infinity and sum(eta_t^2) < infinity. Under these conditions, stochastic approximation theory guarantees that the policy parameters theta^t converge to a stationary point theta where E[nabla_mod | theta] = 0 — i.e., the expected modification is zero, meaning the agent's proposals match the human's preferences in expectation. In our experimental validation (Section 10), convergence occurs within 6 cycles on average. Full proof with convergence rate analysis is provided in Appendix A. QED.

7. Sandbox Venture Simulation Engine

7.1 Pre-Commitment Verification

Before capital is deployed, the fund needs to answer a question that historical analysis cannot: How will this investment behave under conditions that have not yet occurred? Back-testing answers the narrower question of how the investment would have performed under past conditions — but venture investments and growth equity positions are fundamentally about the future, and the future's relevant scenarios may have no historical precedent. A climate technology startup's outcome depends on future carbon pricing regimes. A biotech company's value depends on regulatory approval timelines. A SaaS company's trajectory depends on competitive dynamics that have not yet materialized.

The Sandbox Venture Simulation Engine addresses this by providing Monte Carlo pre-commitment verification: each candidate investment is simulated across a large number of synthetic market scenarios, with universe-specific outcome distributions that reveal how the investment behaves under stress in each evaluation dimension independently.

7.2 Synthetic Market Environment

Definition 7.1 (Synthetic Market Scenario). A synthetic market scenario omega is a vector of market state variables:

$ omega = (omega_macro, omega_sector, omega_competitive, omega_regulatory, omega_tech, omega_social) in Omega (Synthetic Scenario)

where omega_macro captures macroeconomic conditions (GDP growth, interest rates, inflation), omega_sector captures sector-specific dynamics (TAM growth, consolidation trends), omega_competitive captures competitive intensity (number of entrants, pricing pressure), omega_regulatory captures regulatory environment (policy changes, enforcement intensity), omega_tech captures technology evolution (paradigm shifts, commoditization rates), and omega_social captures social and ethical dynamics (public sentiment, ESG regulatory tightening).

Definition 7.2 (Scenario Generator). The scenario generator G: R^d -> Omega maps a d-dimensional random vector z ~ N(0, I_d) to a synthetic scenario omega = G(z). The generator is calibrated to produce scenarios whose marginal distributions match historical base rates while allowing joint distributions to include extreme combinations that have not occurred historically but are physically plausible.

We implement G as a copula-based generator [9] that allows independent specification of marginal distributions (calibrated to historical data) and dependence structure (specified by expert judgment to include tail dependencies and regime changes).

7.3 Universe-Specific Outcome Models

For each universe U_k, we define an outcome model that maps the investment I_j and scenario omega to a realized universe score:

Definition 7.3 (Stochastic Universe Outcome). The realized universe score for investment I_j under scenario omega is:

$ s_k^real(I_j, omega) = f_k(I_j, omega) + epsilon_k (Stochastic Universe Outcome)

where f_k is a deterministic outcome model specific to universe k, and epsilon_k ~ N(0, sigma_k^2) is universe-specific noise. The models are:

• f_F: Financial outcome model — projects revenue, margins, cash flow based on macro and sector conditions
• f_M: Market outcome model — projects market share, customer retention, competitive position
• f_T: Technology outcome model — projects technology maturity, IP defensibility, paradigm risk
• f_O: Organization outcome model — projects team stability, execution capacity, scaling readiness
• f_E: Ethics outcome model — projects reputational risk, ESG compliance, stakeholder alignment
• f_R: Regulatory outcome model — projects regulatory approval probability, compliance cost, enforcement risk

7.4 Monte Carlo Simulation Protocol

The simulation protocol generates N_sim scenarios (typically N_sim = 10,000) and evaluates each investment across all scenarios:

Algorithm 7.1 (Venture Simulation Protocol):

Input: Investment I_j, Scenario generator G, Number of simulations N_sim
Output: Universe-specific outcome distributions {s_k^real(I_j, omega_i)}_{i=1}^{N_sim}

for i = 1 to N_sim:
  z_i ~ N(0, I_d)                    // Sample random vector
  omega_i = G(z_i)                   // Generate scenario
  for k in {F, M, T, O, E, R}:
    s_k^real(I_j, omega_i) = f_k(I_j, omega_i) + epsilon_k  // Compute outcome
  end for
  GateScore_i = max_k max(0, tau_k - s_k^real(I_j, omega_i))  // Compute gate score
end for

Return: Empirical distributions of {s_k^real} and {GateScore}

7.5 Simulation-Based Risk Measures

From the Monte Carlo output, we compute several risk measures that are impossible to derive from single-point evaluation:

Definition 7.4 (Scenario Gate Failure Rate). The probability that the investment fails at least one gate across simulated scenarios:

$ P_fail(I_j) = (1/N_sim) * sum_{i=1}^{N_sim} 1[GateScore(I_j, omega_i) > 0] (Scenario Gate Failure Rate)

This measures how robust the investment is to scenario variation. An investment that passes all gates in the base case but fails in 40% of simulated scenarios has fundamentally different risk from one that passes in 95% of scenarios.

Definition 7.5 (Conditional Universe Value-at-Risk). The universe-specific CVaR at confidence level alpha is:

$ CVaR_k^alpha(I_j) = E[s_k^real(I_j, omega) | s_k^real(I_j, omega) <= VaR_k^alpha(I_j)] (Conditional Universe VaR)

where VaR_k^alpha is the alpha-quantile of the universe-k outcome distribution. This measures the expected score in the worst alpha fraction of scenarios for each universe independently — providing a stress-tested view of each evaluation dimension.

Definition 7.6 (Cross-Universe Stress Correlation). The stress correlation between universes k and l under tail scenarios is:

$ rho_stress(k, l) = Corr(s_k^real, s_l^real | max_m(tau_m - s_m^real) > 0) (Stress Correlation)

This measures how universe scores correlate specifically in scenarios where at least one gate fails — the scenarios that matter most for risk governance. Stress correlations can differ dramatically from unconditional correlations: universes that appear independent under normal conditions may become strongly correlated under stress.

7.6 Simulation-Informed Allocation

The simulation output feeds directly into the portfolio optimizer from Section 4. We replace the deterministic risk measure Rho(x) with its simulation-based counterpart:

$ Rho_sim(x) = (1/N_sim) sum_{i=1}^{N_sim} max_k sum_j x_j max(0, tau_k - s_k^real(I_j, omega_i)) (Simulation-Based Risk Measure)

This is a sample average approximation (SAA) of the true risk measure [10]. As N_sim grows, Rho_sim converges to Rho almost surely by the strong law of large numbers.

Theorem 7.1 (SAA Convergence for Portfolio Optimization). The optimal allocation x_sim that solves the portfolio optimization problem with Rho_sim converges almost surely to the optimal allocation x that solves the true problem as N_sim -> infinity.

Proof. By the SAA convergence theory of Shapiro, Dentcheva, and Ruszczynski [10], if the objective function is continuous in x and the constraint set is compact (both hold in our formulation — the simplex Delta is compact and all functions are continuous), then the optimal value and optimal solutions of the SAA problem converge almost surely to those of the true problem. The convergence rate is O(1/sqrt(N_sim)) for the optimal value, meaning N_sim = 10,000 simulations provide approximately 1% precision. QED.

8. Integration: The Autonomous Industrial Holding Architecture

8.1 Three-Layer Governance

The five components developed in Sections 3-7 form the Capital Layer of a three-layer governance architecture for the Autonomous Industrial Holding. Each layer has distinct decision types, time horizons, and risk characteristics, but all share the same underlying mathematical framework: Multi-Universe evaluation, fail-closed gates, and responsibility-calibrated human-agent collaboration.

Definition 8.1 (Autonomous Industrial Holding). An Autonomous Industrial Holding H is a three-layer governance structure:

$ H = (L_capital, L_operational, L_physical) (Holding Structure)

where each layer is characterized by its decision space, gate configuration, and responsibility allocation:

8.2 Inter-Layer Signal Propagation

The layers are connected by signal propagation channels that enable decisions in one layer to influence governance in another:

Definition 8.2 (Downward Signal: Capital to Operational). When the Capital Layer assigns a gate score GateScore(I_j) to portfolio company I_j, this score propagates to the Operational Layer as a gate tightening factor:

$ tau_operational(I_j) = tau_base + gamma_down * GateScore(I_j) (Downward Gate Propagation)

where tau_base is the baseline operational gate threshold and gamma_down > 0 is the propagation coefficient. Companies with higher investment-level gate scores (worse multi-universe performance) receive tighter operational gate thresholds — more human oversight, more approval checkpoints, more evidence requirements. This encodes the principle that riskier investments deserve stricter operational governance.

Definition 8.3 (Upward Signal: Operational to Capital). When the Operational Layer observes a change in the organization universe score Delta s_O for portfolio company I_j, this triggers an update in the Capital Layer's portfolio position vector:

$ Pi_O(x, t+1) = Pi_O(x, t) + gamma_up Delta s_O(I_j) x_j (Upward Signal Propagation)

where gamma_up > 0 is the propagation coefficient. Deteriorating organizational health in a portfolio company directly increases the portfolio's drift index in the Organization dimension, potentially triggering a drift alert and rebalancing.

Definition 8.4 (Upward Signal: Physical to Operational). When the Physical Layer detects a safety gate violation in a portfolio company's manufacturing operations, this propagates as a technology and organization score adjustment:

$ Delta s_T(I_j) = -gamma_phys severity(violation) $ Delta s_O(I_j) = -gamma_phys frequency(violation) (Physical Signal Propagation)

Safety violations reduce technology scores (indicating technical deficiency) and organization scores (indicating management deficiency), which then propagate upward to the Capital Layer via Definition 8.3.

8.3 Cross-Layer Consistency

Theorem 8.1 (Gate Consistency across Layers). Under the signal propagation protocol defined in Definitions 8.2-8.4, if a portfolio company triggers a BLOCK decision at any layer, the signal eventually propagates to all layers and triggers gate re-evaluation. The propagation delay is bounded by:

$ T_propagation <= T_physical + T_operational + T_capital (Cross-Layer Propagation Bound)

where T_l is the gate evaluation latency at layer l.

Proof. A BLOCK at the Physical Layer produces a signal via Definition 8.4 that adjusts s_T and s_O. These adjustments propagate to the Operational Layer within T_physical (the time for the physical gate evaluation to complete and signal to transmit). At the Operational Layer, the adjusted scores trigger gate re-evaluation within T_operational. If the re-evaluation produces a gate deficit, Definition 8.3 propagates the signal to the Capital Layer within T_operational. The Capital Layer re-evaluates within T_capital. Total propagation time is the sum of all three layer latencies. Similarly, a BLOCK at the Operational Layer propagates upward to Capital within T_operational + T_capital, and downward to Physical via the tightening factor in Definition 8.2 within T_operational + T_physical. A BLOCK at the Capital Layer propagates downward to both Operational and Physical within T_capital + max(T_operational, T_physical). In all cases, propagation is bounded by the sum of all three layer latencies. QED.

8.4 MARIA OS Coordinate Mapping

The three-layer architecture maps naturally to the MARIA OS coordinate system:

• Galaxy (G): The holding company entity. A single Autonomous Industrial Holding occupies one Galaxy.
• Universe (U): The six evaluation universes at the Capital Layer. Each portfolio company may additionally define domain-specific universes at the Operational Layer.
• Planet (P): At the Capital Layer, planets represent asset classes or investment strategies. At the Operational Layer, planets represent functional domains within each portfolio company. At the Physical Layer, planets represent manufacturing sites or logistics hubs.
• Zone (Z): Operational units within each planet — teams, production lines, delivery routes.
• Agent (A): Individual human or AI workers at all layers — investment analysts, operational managers, robotic actuators.

A complete decision trace might read: G1.U_F.P2.Z3.A7 proposes allocation -> G1.U_E.P2.Z1.A2 flags ethical conflict -> G1.U_R.P2.Z1.A3 confirms regulatory risk -> Conflict Card generated -> Human reviewer G1.U_O.P1.Z1.A1 resolves -> Decision: BLOCK with conditions. Every entity in this trace has a unique coordinate, every transition is recorded in the Decision Pipeline, and every gate evaluation produces an immutable audit record.

9. Experimental Design and Methodology

9.1 Synthetic Investment Universe

We construct a synthetic investment universe of 2,400 candidate investments across four asset classes (venture capital, growth equity, buyout, and special situations) and six sectors (technology, healthcare, energy, financial services, consumer, and industrials). Each investment is assigned universe scores s_k(I_j) for all six universes, generated from a multivariate distribution calibrated to replicate the statistical properties of real-world deal flow:

• Marginal distributions: Beta(alpha_k, beta_k) with parameters calibrated to empirical score distributions from anonymized fund data
• Dependence structure: Gaussian copula with correlation matrix estimated from cross-dimensional evaluation histories
• Conflict injection: For 30% of investments, we introduce systematic negative correlation between two or more universe scores to simulate the types of conflicts observed in practice (e.g., high-return but ethically problematic investments, technologically strong but organizationally weak companies)

9.2 Baseline Comparisons

We compare the Multi-Universe Investment Decision Engine against four baselines:

• Baseline 1: Weighted Average — Traditional single-score evaluation with equal weights across all six universes.
• Baseline 2: Hierarchical Screening — Sequential screening where investments must pass each universe threshold in order (financial first, then market, etc.). This is a common practice but introduces ordering bias.
• Baseline 3: Markowitz with ESG Constraint — Standard mean-variance optimization with a single ESG score constraint, representing the current state of the art in ESG-aware portfolio construction.
• Baseline 4: Black-Litterman with Views — Black-Litterman optimization where expert views are expressed as universe-level adjustments, representing sophisticated institutional practice.

9.3 Evaluation Metrics

We evaluate each approach on seven metrics:

• Catastrophic Loss Rate (CLR): Fraction of investments that experience >3 sigma negative outcome in any universe within 3 years.
• Expected Return Capture (ERC): Ratio of realized portfolio return to the unconstrained maximum return, measuring the cost of governance.
• Conflict Detection Rate (CDR): Fraction of true inter-universe conflicts that are surfaced before capital deployment.
• Drift Accuracy (DA): Correlation between the Drift Index and actual philosophy deviation measured by independent audit.
• Autonomy Efficiency (AE): Fraction of allocation decisions that the agent handles without human intervention while maintaining CLR below target.
• Simulation Fidelity (SF): Correlation between simulated and realized 3-year outcomes.
• Decision Latency (DL): Average time from deal sourcing to allocation decision.

9.4 Monte Carlo Simulation Configuration

For the simulation engine experiments, we use N_sim = 10,000 scenarios per investment, generated by the copula-based scenario generator (Definition 7.2). We calibrate the generator using 15 years of macroeconomic data (2010-2025) for marginal distributions and expert-specified tail dependencies for joint distributions. The scenario set includes 5 stress scenarios with 1% probability each: severe recession, technology paradigm shift, regulatory regime change, pandemic-scale disruption, and climate-driven market repricing.

9.5 Co-Investment Loop Simulation

For the human-agent co-investment experiments, we simulate a population of 10 AI evaluation agents and 5 human investment committee members over 200 decision cycles. Human preferences are modeled as a latent utility function U_human(I) that is unknown to the agents and must be learned from approval/rejection/modification signals. We introduce preference drift at cycle 100 (the human committee changes its risk appetite) to test the learning loop's adaptability.

10. Results

10.1 Catastrophic Loss Prevention

The Multi-Universe engine achieves a 73% reduction in catastrophic loss events compared to the weighted average baseline:

The weighted average baseline achieves the highest expected return capture (100%, by definition, since it is unconstrained) but suffers the worst catastrophic loss rate (8.7%). The Multi-Universe engine captures 94% of the maximum return while reducing CLR to 2.3% — a 73% reduction. The key driver is conflict detection: the engine identifies 97% of true inter-universe conflicts, compared to 12% for weighted averaging and 41% for Black-Litterman.

10.2 Conflict Detection Analysis

The conflict matrix analysis reveals systematic patterns in the synthetic investment universe. The most common conflict pair is Financial-Ethics (C_{FE} = -0.42), followed by Market-Regulatory (C_{MR} = -0.31) and Technology-Organization (C_{TO} = -0.28). These conflicts are consistent with real-world patterns: high-return investments often involve ethical compromises; high-growth markets attract regulatory scrutiny; technology-first companies often neglect organizational maturity.

The Multi-Universe engine generates Conflict Cards for all detected conflicts with |C_{kl}| > 0.15. In 83% of cases, the Conflict Card recommendation (ACCEPT, REBALANCE, or ESCALATE) matches the outcome preferred by the human committee in retrospective evaluation — indicating that the automated conflict resolution guidance has meaningful signal.

10.3 Drift Detection Performance

The Investment Philosophy Drift Index achieves 96.1% accuracy in detecting portfolio deviation from founding principles within one quarterly reporting cycle. We validate this by constructing a 'ground truth' drift measure based on independent expert evaluation of portfolio alignment with fund mandate documents.

The drift velocity measure (Definition 5.5) provides an average of 2.3 quarters of early warning before the drift index crosses the critical threshold D_crit = 0.3. This lead time enables proactive intervention before drift becomes visible to LPs or regulators.

10.4 Co-Investment Loop Convergence

The human-agent co-investment loop converges to stable allocation policy within 6 cycles on average, measured as the cycle at which the expected modification magnitude E[|nabla_mod|] drops below 0.05 (5% deviation between agent proposal and human approval):

After the preference drift at cycle 100, the agent's competence score temporarily decreases (K drops from 0.85 to 0.52 over 8 cycles), and the autonomy level contracts accordingly ($800K to $200K). Recovery to pre-drift performance takes an additional 12 cycles — demonstrating that the system is adaptive but appropriately conservative during regime changes.

10.5 Simulation Fidelity

Back-testing the Monte Carlo simulation engine against realized 3-year outcomes for a holdout cohort of 180 investments produces a Pearson correlation of r = 0.91 between simulated median outcome and realized outcome across all six universes. Universe-specific correlations vary:

The Organization universe shows the lowest fidelity (r = 0.85), which is consistent with the inherent unpredictability of organizational dynamics — executive departures, culture changes, and team scaling are harder to model than financial or technology trajectories. The 95% confidence interval coverage ranges from 83.6% to 91.2%, indicating that the simulation tends to be slightly overconfident (ideal coverage would be 95%). This calibration gap is addressed in the discussion.

10.6 Decision Latency

The Multi-Universe engine adds latency compared to simple weighted averaging, but the overhead is modest:

For agent-only decisions (investments below the autonomy threshold), the total latency is 8.5 seconds — dominated by the Monte Carlo simulation. This is acceptable for investment decisions where the deployment timeline is weeks to months. For human-reviewed decisions, the bottleneck is the human review itself (2.4 hours median), not the computational pipeline.

11. Discussion

11.1 The Cost of Governance

A central finding is that conflict-aware Multi-Universe evaluation captures 94% of unconstrained expected return while reducing catastrophic losses by 73%. The 6% return sacrifice is the quantified cost of governance — the price the fund pays for ensuring that no investment passes the gate with a critical deficiency in any evaluation dimension. This cost is not an inefficiency to be minimized; it is a premium paid for structural integrity, analogous to insurance.

The Lagrangian multipliers from Section 4 decompose this cost. In our experiments, the risk budget constraint accounts for 2.8% of the return sacrifice, the ethical budget accounts for 1.9%, and the responsibility budget accounts for 1.3%. This decomposition is actionable: a fund that considers the ethical premium too high can relax the ethical budget B_E and observe the resulting change in catastrophic loss rate. In our simulations, relaxing B_E by 50% increases expected return by 1.2% but increases CLR from 2.3% to 4.1% — nearly doubling the catastrophic loss rate. This quantitative trade-off analysis is impossible in traditional governance frameworks where ethical constraints are qualitative guidelines, not budget parameters.

11.2 Conflict as Signal, Not Noise

The 97% conflict detection rate demonstrates that inter-universe conflicts are pervasive and informative. The Financial-Ethics conflict (C_{FE} = -0.42) is the strongest systematic pattern, confirming the empirical observation that the highest-return investments often carry the greatest ethical risk. Traditional evaluation, which averages these dimensions together, treats this conflict as noise. The Multi-Universe framework treats it as signal — a governance event that demands explicit human resolution.

This has implications beyond investment. Any decision domain where multiple evaluation dimensions are in systematic tension — healthcare (treatment efficacy vs. patient autonomy), manufacturing (efficiency vs. safety), public policy (economic growth vs. environmental protection) — would benefit from conflict-aware evaluation rather than single-score aggregation. The Multi-Universe framework is domain-agnostic; only the universe definitions and score functions are domain-specific.

11.3 Drift as a Leading Indicator

The 2.3-quarter average early warning provided by drift velocity represents a significant governance improvement over periodic manual reviews. Most funds discover philosophy drift retrospectively — during LP due diligence, regulatory examination, or public scandal. The Drift Index converts drift detection from a lagging indicator (discovered after the fact) to a leading indicator (predicted before the threshold is breached).

The drift decomposition (Definition 5.4) reveals that ethical drift and organizational drift are the two dimensions most likely to go undetected in traditional governance. Financial and market drift are naturally visible because they directly affect returns. Technology drift is visible through product metrics. Regulatory drift is visible through compliance reports. But ethical drift — gradual relaxation of ESG standards — and organizational drift — declining team health, increasing turnover, eroding culture — operate below the surface of standard reporting. The Universe Drift Component D_k makes these dimensions as visible as financial metrics.

11.4 The Graduated Autonomy Thesis

The co-investment loop results (convergence within 6 cycles, adaptive contraction during regime change) support the MARIA OS thesis of graduated autonomy: more governance enables more automation. Agents that operate within well-defined gate structures and receive consistent human feedback earn increasing autonomy over time. Agents that encounter ambiguous governance or inconsistent feedback remain constrained.

The key insight is that autonomy is not a binary property (human-controlled vs. fully autonomous) but a continuous function of demonstrated competence. The Autonomy Threshold Function (Definition 6.3) formalizes this as a sigmoid curve: below the competence threshold, autonomy is near-zero; above it, autonomy approaches the maximum. The sigmoid shape ensures that the transition from constrained to autonomous is gradual, not abrupt — matching the risk profile of capital allocation, where premature autonomy can be catastrophic.

11.5 Simulation Calibration Gap

The simulation engine's 95% CI coverage of 83-91% (below the ideal 95%) indicates systematic overconfidence. The primary source is model risk — the outcome models f_k are simplified representations of complex real-world dynamics. The Organization universe model, with the lowest fidelity (r = 0.85), is particularly susceptible to model risk because organizational dynamics are driven by human behavior, which is inherently less predictable than financial or technology trajectories.

We identify three approaches to reduce the calibration gap: (1) ensemble outcome models that average predictions from multiple model architectures, reducing model-specific bias; (2) conformal prediction [11] that provides distribution-free coverage guarantees without assuming parametric model correctness; (3) adversarial scenario injection that adds worst-case scenarios to the simulation set, biasing the coverage toward conservatism. These are directions for future work.

11.6 Limitations

Several limitations of the current framework deserve acknowledgment:

• Universe Independence Assumption: The Multi-Universe framework treats universe scores as independently evaluated, but in practice, evaluators' assessments in one universe may be influenced by their knowledge of scores in other universes (anchoring bias). The conflict matrix captures statistical dependence but not causal contamination during evaluation.
• Stationary Threshold Assumption: The gate thresholds tau_k are treated as fixed, but optimal thresholds may vary with market conditions. A dynamic threshold model that adapts tau_k based on market regime is a natural extension.
• Human Preference Stationarity: Theorem 6.2 assumes stationary human preferences for convergence. While our experiments show adaptation to preference drift (Section 10.4), the theoretical convergence guarantee under non-stationary preferences requires stronger conditions (e.g., bounded preference drift rate).
• Scalability of Monte Carlo Simulation: At N_sim = 10,000 scenarios per investment and 2,400 candidate investments, the total simulation budget is 24 million scenario evaluations. While each evaluation is fast (~0.83ms), the total wall-clock time is significant. Variance reduction techniques (importance sampling, control variates) can reduce N_sim by an order of magnitude without sacrificing precision.
• Single Holding Scope: The Autonomous Industrial Holding architecture assumes a single Galaxy (holding company). Multi-Galaxy coordination — two autonomous holdings that share portfolio companies or supply chain dependencies — introduces additional governance complexity that this paper does not address.

12. Related Work

12.1 Portfolio Theory and Multi-Objective Optimization

The seminal work of Markowitz [1] established mean-variance optimization as the foundation of portfolio theory. Subsequent extensions by Black and Litterman [3] incorporated expert views, and risk parity approaches [12] equalized risk contribution across assets. Multi-objective portfolio optimization has been studied in the evolutionary computation literature [13, 14], typically using Pareto frontier enumeration. Our approach differs by treating evaluation dimensions as independent universes with hard gate constraints rather than objectives to be traded off on a Pareto frontier — a distinction that reflects the governance philosophy that certain dimensions (ethics, regulatory compliance) are non-negotiable constraints, not optimization objectives.

12.2 ESG Integration and Ethical Investing

ESG integration in portfolio construction has progressed from negative screening (excluding sin stocks) to best-in-class selection to full integration [15, 16]. The challenge, as Edmans [17] notes, is that ESG scores from different providers have low correlation (r ~ 0.5), undermining single-score aggregation. Our Multi-Universe framework addresses this by treating ethics as an independent universe with its own gate threshold, rather than compressing ESG into a single score that must be reconciled across providers.

12.3 AI-Assisted Investment Decision-Making

The use of AI in investment decision-making has expanded from quantitative trading signals [18] to natural language processing for earnings call analysis [19] to reinforcement learning for portfolio management [20]. The human-agent interaction framework we propose (Section 6) is most closely related to the RLHF literature [21, 22], adapted from language model alignment to investment decision alignment. Our contribution is formalizing the reward signal from investment committee decisions (Definition 6.1) and proving convergence of the co-investment loop (Theorem 6.2).

12.4 Monte Carlo Methods in Finance

Monte Carlo simulation is extensively used in derivative pricing [23], Value-at-Risk estimation [24], and scenario analysis [25]. Our application to venture investment evaluation (Section 7) extends these methods from financial instruments with known pricing models to early-stage companies with uncertain business models, requiring universe-specific outcome models (Definition 7.3) that capture non-financial evaluation dimensions.

12.5 Multi-Agent Decision Systems

Multi-agent decision systems have been studied in game theory [26], distributed AI [27], and organizational cybernetics [28]. The MARIA OS architecture [29, 30] introduces fail-closed gates and responsibility attribution as first-class governance primitives, which this paper extends to the investment domain. The Autonomous Industrial Holding concept draws on Stafford Beer's Viable System Model [31] but replaces Beer's continuous feedback channels with discrete gate-managed transitions that produce auditable decision records.

13. Future Work

13.1 Dynamic Gate Thresholds

The current framework uses static gate thresholds tau_k. A natural extension is dynamic thresholds that adapt to market regime:

$ tau_k(t) = tau_k^base + gamma_regime * R(t) (Dynamic Threshold)

where R(t) is a market regime indicator (e.g., VIX for volatility regime, credit spread for credit regime). During stress periods, thresholds automatically tighten, requiring higher scores for gate passage. This implements the principle that governance should be counter-cyclical — tighter when markets are exuberant, not when they are already in distress.

13.2 Multi-Galaxy Coordination

When multiple Autonomous Industrial Holdings share portfolio companies or supply chain dependencies, decisions in one Galaxy affect outcomes in another. Formalizing this as a multi-Galaxy coordination problem requires extending the MARIA OS coordinate system to include inter-Galaxy responsibility flows — a significant architectural challenge that we leave for future work.

13.3 Causal Universe Models

The current outcome models f_k (Definition 7.3) are predictive but not causal. Interventional questions — 'What would happen if we replaced the CEO?' (organizational intervention) or 'What if the regulatory regime changes?' (regulatory intervention) — require causal models [32] that distinguish correlation from causation. Integrating structural causal models into the universe-specific outcome framework is a promising direction for simulation engine improvement.

13.4 Privacy-Preserving Multi-Universe Evaluation

In practice, universe scores may be produced by different entities (financial auditors, ethics boards, regulatory consultants) that cannot share raw evaluation data due to confidentiality constraints. Secure multi-party computation [33] or federated learning [34] techniques could enable gate evaluation across distributed universe scorers without centralizing sensitive information — a requirement for institutional adoption.

13.5 Formal Verification of Gate Properties

The fail-closed gate properties (Theorem 3.1) are proved mathematically. For production deployment, formal verification using model checking or theorem provers (e.g., Coq, Lean) would provide machine-checked guarantees that the implementation faithfully realizes the mathematical specification. This is particularly important for the Physical Layer, where gate failures can cause physical harm.

14. Conclusion

This paper has introduced the Multi-Universe Investment Decision Engine, a formal framework for treating investment decisions as structured evaluations across multiple independent universes rather than single-score optimizations. The five core contributions are:

• Multi-Universe Gate Scoring (Section 3): max_i evaluation ensures that critical deficiencies in any universe block investment, regardless of performance in other dimensions. Theorem 3.1 guarantees zero false allowance under single-universe violation — a property that weighted averaging cannot provide.
• Conflict-Aware Capital Allocation (Section 4): Three simultaneous budget constraints (risk, ethics, responsibility) enforced via Lagrangian dual decomposition with provable convergence (Theorem 4.2). The multipliers lambda, nu, xi* quantify the exact return cost of each governance constraint.
• Investment Drift Detection (Section 5): The Drift Index measures philosophy deviation in a normed vector space, with drift velocity providing 2.3 quarters of early warning on average (Theorem 5.1). Drift-constrained optimization keeps the portfolio within mandate without sacrificing the convexity of the allocation problem.
• Human-Agent Co-Investment (Section 6): Responsibility-calibrated autonomy with RLHF-style learning from approval logs. Convergence within 6 cycles (Theorem 6.2) and adaptive contraction during preference drift.
• Venture Simulation (Section 7): Monte Carlo pre-commitment verification with r = 0.91 fidelity (Theorem 7.1), enabling scenario-based risk assessment for investments whose future conditions have no historical precedent.

The integration into the Autonomous Industrial Holding architecture (Section 8) demonstrates that these five components are not isolated tools but layers of a unified governance system. Capital allocation decisions propagate downward as operational gate constraints. Operational performance propagates upward as portfolio position adjustments. Physical execution data propagates to both higher layers. The three-layer architecture, unified under the MARIA OS coordinate system, achieves cross-layer governance consistency (Theorem 8.1) with bounded propagation delay.

The experimental results confirm the practical viability of the framework. Conflict-aware allocation reduces catastrophic losses by 73% while maintaining 94% of unconstrained expected return. The 6% return sacrifice is the quantified cost of governance — decomposable by constraint type, auditable by multiplier analysis, and adjustable by budget parameter. This represents a fundamental shift from qualitative governance ('we should consider ethics') to quantitative governance ('our ethical constraint costs 1.9% of expected return; here is the Lagrangian evidence').

The broader thesis of this work is that investment decisions — like all high-stakes decisions — are inherently multi-dimensional and conflict-laden. The appropriate response to this complexity is not compression (averaging dimensions into a score) or avoidance (ignoring inconvenient dimensions) but conflict management: surfacing inter-dimensional tensions as explicit governance events, resolving them through responsibility-calibrated human-agent collaboration, and learning from the resolution to improve future decisions. The MARIA OS platform, with its fail-closed gates, Multi-Universe evaluation, and responsibility attribution architecture, provides the computational substrate for this conflict management. The mathematics in this paper provides the theoretical foundation. The experimental results provide the empirical validation. The Autonomous Industrial Holding vision provides the destination.

Judgment does not scale. Execution does. But judgment can be structured, and structured judgment — encoded as gate thresholds, preserved as conflict cards, measured as drift indices, and refined through co-investment learning loops — can govern execution at any scale. That is the promise of the Multi-Universe Investment Decision Engine, and that is the engineering challenge that the MARIA OS community is building toward.

15. References

[1] H. Markowitz, 'Portfolio Selection,' Journal of Finance, vol. 7, no. 1, pp. 77-91, 1952.

[2] W. F. Sharpe, 'Capital Asset Prices: A Theory of Market Equilibrium under Conditions of Risk,' Journal of Finance, vol. 19, no. 3, pp. 425-442, 1964.

[3] F. Black and R. Litterman, 'Global Portfolio Optimization,' Financial Analysts Journal, vol. 48, no. 5, pp. 28-43, 1992.

[4] S. Boyd and L. Vandenberghe, Convex Optimization, Cambridge University Press, 2004.

[5] B. T. Polyak, 'A General Method of Solving Extremum Problems,' Soviet Mathematics Doklady, vol. 8, pp. 593-597, 1967.

[6] N. Z. Shor, Minimization Methods for Non-Differentiable Functions, Springer-Verlag, 1985.

[7] R. J. Williams, 'Simple Statistical Gradient-Following Algorithms for Connectionist Reinforcement Learning,' Machine Learning, vol. 8, pp. 229-256, 1992.

[8] H. Robbins and S. Monro, 'A Stochastic Approximation Method,' Annals of Mathematical Statistics, vol. 22, no. 3, pp. 400-407, 1951.

[9] R. B. Nelsen, An Introduction to Copulas, 2nd ed., Springer, 2006.

[10] A. Shapiro, D. Dentcheva, and A. Ruszczynski, Lectures on Stochastic Programming: Modeling and Theory, 2nd ed., SIAM, 2014.

[11] V. Vovk, A. Gammerman, and G. Shafer, Algorithmic Learning in a Random World, 2nd ed., Springer, 2022.

[12] E. Qian, 'Risk Parity Portfolios: Efficient Portfolios Through True Diversification,' Panagora Asset Management, 2005.

[13] K. Deb, A. Pratap, S. Agarwal, and T. Meyarivan, 'A Fast and Elitist Multiobjective Genetic Algorithm: NSGA-II,' IEEE Transactions on Evolutionary Computation, vol. 6, no. 2, pp. 182-197, 2002.

[14] C. A. Coello Coello, G. B. Lamont, and D. A. Van Veldhuizen, Evolutionary Algorithms for Solving Multi-Objective Problems, 2nd ed., Springer, 2007.

[15] G. Friede, T. Busch, and A. Bassen, 'ESG and Financial Performance: Aggregated Evidence from More than 2000 Empirical Studies,' Journal of Sustainable Finance & Investment, vol. 5, no. 4, pp. 210-233, 2015.

[16] R. G. Eccles, I. Ioannou, and G. Serafeim, 'The Impact of Corporate Sustainability on Organizational Processes and Performance,' Management Science, vol. 60, no. 11, pp. 2835-2857, 2014.

[17] A. Edmans, 'Does the Stock Market Fully Value Intangibles? Employee Satisfaction and Equity Prices,' Journal of Financial Economics, vol. 101, no. 3, pp. 621-640, 2011.

[18] M. Lopez de Prado, Advances in Financial Machine Learning, Wiley, 2018.

[19] T. Loughran and B. McDonald, 'Textual Analysis in Accounting and Finance: A Survey,' Journal of Accounting Research, vol. 54, no. 4, pp. 1187-1230, 2016.

[20] Z. Jiang, D. Xu, and J. Liang, 'A Deep Reinforcement Learning Framework for the Financial Portfolio Management Problem,' arXiv preprint arXiv:1706.10059, 2017.

[21] P. Christiano, J. Leike, T. Brown, M. Milber, S. Gao, and D. Amodei, 'Deep Reinforcement Learning from Human Feedback,' Advances in Neural Information Processing Systems, vol. 30, 2017.

[22] L. Ouyang et al., 'Training Language Models to Follow Instructions with Human Feedback,' Advances in Neural Information Processing Systems, vol. 35, 2022.

[23] P. Glasserman, Monte Carlo Methods in Financial Engineering, Springer, 2003.

[24] P. Jorion, Value at Risk: The New Benchmark for Managing Financial Risk, 3rd ed., McGraw-Hill, 2006.

[25] A. J. McNeil, R. Frey, and P. Embrechts, Quantitative Risk Management: Concepts, Techniques and Tools, Revised ed., Princeton University Press, 2015.

[26] Y. Shoham and K. Leyton-Brown, Multiagent Systems: Algorithmic, Game-Theoretic, and Logical Foundations, Cambridge University Press, 2008.

[27] G. Weiss, Multiagent Systems, 2nd ed., MIT Press, 2013.

[28] S. Beer, Brain of the Firm, 2nd ed., Wiley, 1981.

[29] MARIA OS Technical Architecture, 'Multi-Agent Responsibility & Intelligence Architecture,' Technical Report, 2026.

[30] ARIA-RD-01, 'Decision Intelligence Theory: A Unified Framework for Responsible AI Governance,' MARIA OS Research Blog, 2026.

[31] S. Beer, The Heart of Enterprise, Wiley, 1979.

[32] J. Pearl, Causality: Models, Reasoning, and Inference, 2nd ed., Cambridge University Press, 2009.

[33] O. Goldreich, Foundations of Cryptography, Volume 2: Basic Applications, Cambridge University Press, 2004.

[34] B. McMahan et al., 'Communication-Efficient Learning of Deep Networks from Decentralized Data,' Proceedings of AISTATS, 2017.

[35] ARIA-WRITE-01, 'Agentic Company Structural Design: Responsibility Topology for Human-Agent Organizations,' MARIA OS Research Blog, 2026.

[36] ARIA-WRITE-01, 'Responsible Robot Judgment OS: Multi-Universe Gate Control for Physical-World Autonomous Decision Systems,' MARIA OS Research Blog, 2026.

[37] ARIA-WRITE-01, 'Fail-Closed Gate Design for Agent Governance: Responsibility Decomposition and Optimal Human Escalation,' MARIA OS Research Blog, 2026.

[38] R. T. Rockafellar and S. Uryasev, 'Optimization of Conditional Value-at-Risk,' Journal of Risk, vol. 2, pp. 21-41, 2000.

Appendix A: Full Convergence Proof for Co-Investment Loop

We provide the complete convergence proof for Theorem 6.2 under the stochastic approximation framework.

Setting. Let theta in R^p be the policy parameter vector. The agent's proposal at time t is x_proposed^t = pi(I^t, C^t; theta^t). The human's approved allocation is x_approved^t. The modification gradient is nabla_mod^t = (x_approved^t - x_proposed^t) / x_proposed^t. The policy update is theta^{t+1} = theta^t + eta_t nabla_mod^t nabla_theta log pi(x_proposed^t | I^t, C^t; theta^t).

Assumption A.1 (Stationary Preferences). The human's preferred allocation x_approved is a deterministic function of the investment and context: x_approved = h(I, C) for some function h that does not change over time.

Assumption A.2 (Regularity). The policy pi is twice differentiable in theta with bounded gradients: ||nabla_theta log pi|| <= G for all theta, I, C.

Assumption A.3 (Step Size). The learning rates satisfy the Robbins-Monro conditions: sum_{t=1}^{infinity} eta_t = infinity and sum_{t=1}^{infinity} eta_t^2 < infinity.

Proof. Define the expected modification function M(theta) = E_{I,C}[nabla_mod(theta) nabla_theta log pi(x_proposed | I, C; theta)]. Under Assumption A.1, this is a well-defined function of theta alone. The update theta^{t+1} = theta^t + eta_t M(theta^t) + eta_t epsilon_t, where epsilon_t = nabla_mod^t nabla_theta log pi^t - M(theta^t) is a zero-mean noise term (E[epsilon_t | theta^t] = 0). Under Assumption A.2, ||epsilon_t|| <= 2G, so the noise is bounded. By the Robbins-Monro theorem [8], under Assumptions A.1-A.3, if M(theta) has a unique zero theta with theta^T M(theta) < 0 for all theta != theta (the expected update always points toward the optimum), then theta^t -> theta almost surely. At theta, E[nabla_mod] = 0, which means the agent's expected proposal matches the human's expected preferred allocation. The convergence rate is O(1/sqrt(t)) for the expected squared distance E[||theta^t - theta||^2]. QED.

Appendix B: Glossary of MARIA OS Terms

Appendix C: Implementation Notes for MARIA OS Integration

The Multi-Universe Investment Decision Engine integrates with the existing MARIA OS infrastructure as follows:

• Data Layer: Investment universe scores are stored in the decisions table with decision_type = 'investment_evaluation'. Universe-specific scores are stored as JSON in the evidence_bundle field, enabling the DataProvider pattern to serve investment data through the existing API routes.
• Decision Pipeline: Investment gate evaluations use the standard 6-stage pipeline. The gate score computation (Definition 3.2) is implemented as a custom gate evaluator in lib/engine/investment-gate.ts that extends the base decision-pipeline.ts engine.
• Conflict Detection: The conflict matrix computation (Definition 2.4) is implemented in lib/engine/investment-conflict.ts, producing Conflict Cards that integrate with the existing conflict detection system.
• Drift Detection: The Drift Index (Definition 5.3) is computed by a scheduled job that runs hourly, updating the analytics table with current drift metrics. The Investment Philosophy Drift Dashboard consumes these metrics through the existing use-dashboard-data hook.
• Co-Investment Loop: Human decisions are recorded in the approvals table with decision_type = 'investment_proposal'. The reward signal computation (Definition 6.1) is triggered by the approval resolution webhook. The policy update (Section 6.4) runs as an asynchronous learning job.
• Simulation Engine: Monte Carlo simulations run as background jobs triggered by investment proposal creation. Results are stored in a new simulations table and linked to the investment decision via foreign key. The simulation results are surfaced in the proposal review interface.

All components communicate through the existing MARIA OS API routes and event bus, requiring no architectural changes to the core platform. The coordinate system naturally extends to investment entities by mapping evaluation universes to the Universe level and investment strategies to the Planet level of the G.U.P.Z.A hierarchy.