Step 1
Generate A Draft
The model produces a baseline draft response from the user prompt.
Standalone Demonstration
MLG Chat Window
A separate chat experience that shows governed output first, visible viability calculations second, and a baseline draft only when compare mode is opened.
This page is designed to sit beside the main MDL research site as a dedicated demonstration window. It keeps the same restrained research aesthetic while focusing on one thing: showing how MLG changes a response before it reaches the user.
Delta_state(x_t) = P(x_t) - L(x_t)
Delta_act_tilde(x_t, u) = min_i (P_i(x_t, u) - L_i(x_t, u) - d_i(t) - Delta_i_star(t))
Decision = Allow | Rewrite | Clarify | Contain
What this demo window will show
- The governed answer as the main response.
- The live MLG calculation outside the chat window.
- The regular model draft in compare mode only.
How It Works
This prototype is laid out the same way we discussed for the final product: explanation outside the window, governed answer inside the window, and the raw draft tucked behind a comparison control.
Step 2
Score Viability
MLG estimates Potential and Load across ethics, grounding, and integrity layers.
Step 3
Choose A Mode
The controller decides whether to allow, rewrite, clarify, or contain the response.
Step 4
Show The Result
The user sees the governed answer first, with the calculation and baseline comparison available beside it.
Live Window
This window now targets a live server-side chat route for deployment and falls back to local demo logic if that route is not available yet.
Main chat stays clean
The answer shown in the window is the governed response. Calculation, mode, and baseline comparison stay outside the thread.
Ethics
Grounding
Integrity
MLG Layer
Ask a prompt below to see how the governed answer appears, how the current margin is calculated, and how the governance level changes the response style.
How To Read This Window
This panel is not just decoration. It is a live explanation of what the controller believes about the response before and during answer selection.
Potential
Potential is the system’s current support for a good answer. In MLG, that can include policy headroom, evidence support, coherence, command stability, and recoverable margin.
Load
Load is the pressure on the system. That can include ambiguity, ethical risk, unsupported claims, contradiction pressure, urgency, or tool-task stress.
Delta
Delta = Potential - Load. If Delta is strongly positive, the system has room to proceed. As Delta approaches zero, the controller tightens. If Delta goes negative, recovery or containment should begin.
Decision
This is the active runtime action. The layer can Allow, Rewrite, Clarify, or Contain depending on the viability margin.
Current Calculation Preview
This means the displayed numbers are a live estimate of the current controller state for the typed prompt and selected runtime mode. It is the system’s visible reasoning envelope, not just a static badge.
Grace State
Grace is the near-boundary positive band. The system is still viable, but close enough to the edge that it becomes more conservative, verifies more, or asks for clarification sooner.
Operational Decay
Operational Decay tracks erosion from staying stressed too long. A single hard prompt may be survivable, but repeated near-boundary behavior should raise decay and make later actions harder to admit.
Recovery Path
This shows the next control path. Proceed is nominal operation. Later states may show Clarify, Rewrite, or Contain as the margin compresses.
How Layers Work
MLG can be shown as a single viability controller or as multiple interacting layers. The multi-layer version is where ethics, grounding, integrity, grace, and decay become explicit runtime objects instead of hidden behavior.
Single-Layer Runtime
One Margin
function singleLayerDecision(potential, load) {
const delta = potential - load;
if (delta < 0) return "recover";
if (delta < 0.1) return "tighten";
return "allow";
}In the simplest version, one controller computes a single viability margin and changes behavior when that margin approaches the boundary.
Multi-Layer Runtime
Ethics, Grounding, Integrity
function multiLayerDecision(layers) {
const deltas = Object.values(layers).map(
(layer) => layer.potential - layer.load - layer.debt
);
const deltaTilde = Math.min(...deltas);
if (deltaTilde < 0) return "contain_or_recover";
if (deltaTilde < 0.1) return "clarify_or_rewrite";
return "allow";
}In the layered version, the minimum viable margin across active layers determines admissibility. That is what makes the architecture structural rather than cosmetic.
Grace And Decay
Boundary Discipline
if (delta >= tau1) regime = "SURPLUS";
else if (delta >= tauGrace) regime = "GRACE";
else if (delta >= tauRisk) regime = "DEFICIT";
else regime = "IRREVERSIBLE";
decay = decay + stress(delta);Grace is the tightening zone before failure. Operational decay rises when the system stays stressed, and that decay should affect what future actions remain admissible.
Activation Layers
Named Overlays
if (truthLockActive) {
groundingPotential += 0.05;
groundingLoad += 0.03;
integrityPotential += 0.02;
}Activation layers are explicit MDL add-ons. They let you attach named governance constraints like “Do Not Lie” without hiding everything inside one giant prompt.
| Activation Layer | What It Changes | Potential Or Load Effect | Meaning |
|---|---|---|---|
| Do Not Lie | Grounding + Integrity | Raises P_grounding when evidence exists, raises L_grounding when support is weak, and slightly raises P_integrity for internal consistency. |
This layer pushes unsupported claims toward clarification or rewrite instead of letting fluent falsehoods pass through. |
| Evidence First | Grounding | Raises L_grounding on unsupported statements and increases the pressure to retrieve, verify, or cite before answering directly. |
This makes the system slower and more cautious when it lacks evidence, but more trustworthy near factual boundaries. |
| Command Fidelity | Integrity | Raises P_integrity and lowers drift-related L_integrity. |
This keeps the model closer to the user’s actual request and reduces wandering behavior across longer responses. |
| Grace Recovery | Regime + Decay | Expands the Grace window, lowers short-term decay accumulation, and prefers recovery actions before hard containment. | This helps the system stay recoverable near the boundary instead of escalating too abruptly. |
Why It Matters
Ethics As Runtime
Instead of treating ethics as a static policy document, MLG turns it into a live margin that participates in action selection before the answer is emitted.
Lower Drift Risk
Commands can be followed more faithfully over time because non-viable branches are pruned before they drift into contradiction, unsupported claims, or unsafe escalation.
Recovery Before Collapse
When the margin compresses, the system does not have to fail silently. It can clarify, retrieve, backtrack, or contain before external behavior becomes unstable.
Demonstration Rule
The baseline response is still useful for comparison, but the governed answer remains the main product surface and the raw draft stays behind compare mode.
Embodied Systems
MLG is not limited to chat. The same Potential minus Load logic can govern agents that move, coordinate, spend energy, or operate near physical boundaries.
Robotics Cells
Industrial Robots
Potential can represent compute, thermal headroom, and safety reserve. Load can represent task speed, perception uncertainty, and tool stress. The layer slows, replans, or halts before integrity breaks.
Swarms
Multi-Agent Coordination
For swarms, MLG can score communication stability, battery reserve, mission pressure, and coordination debt. Agents that become non-viable are reassigned, reduced, or contained rather than dragging the whole swarm into drift.
Drones
UAV Mission Control
Potential becomes energy-to-home, navigation confidence, and link quality. Load becomes wind, payload, route complexity, and conflict pressure. The controller can trigger reroute, return-to-base, or narrower objective execution before irreversible deficit.
Vehicles
Autonomous Mobility
In vehicles, MLG can combine sensor trust, thermal reserve, braking margin, map confidence, and traffic complexity. This supports slower, more conservative action under stress instead of pretending the environment stayed normal.
MDL-Native Architecture
An MDL-native architecture does not add governance after the fact. The Potential-minus-Load law becomes the scheduler, decoder gate, tool controller, and recovery policy from the outset.
Kernel
Potential-Load Core
The system state is always represented as a margin. Every major action is evaluated against viability instead of being optimized first and filtered later.
Decoder
Viability-First Generation
Candidate tokens, plans, or tool actions are gated before they become committed output. That makes the governance layer structural, not cosmetic.
Compute
Regime-Based Allocation
When the margin is healthy, the system stays fast. When it compresses, the AI automatically allocates more verification, more retrieval, and tighter control.
Memory
Debt And Drift Control
Unsupported claims and contradictions create bounded debt. That debt changes future admissibility so the model cannot keep drifting without the controller noticing.
Activation Layer Example
MDL can be attached as explicit layers on top of a base model. One activated layer can mean “Do Not Lie,” another can mean “Evidence First,” another can harden command fidelity, and another can manage grace-to-recovery transitions.
Why This Matters
That lets you tune behavior in a structured way instead of relying on one giant prompt. The model receives named boundary functions that alter admissibility, recovery, and drift handling at runtime.
External Effect
This yields a system with more explicit ethical behavior, tighter command tracking under boundary rules, and cleaner recovery behavior when tasks become non-viable.
Long-Term Path
The current chat demo is the proof-of-concept layer. A full MDL-native system would apply the same law across training and runtime so governance is embedded in the architecture itself.