ユースケース

技術的ディープダイブ

階層理論ナビゲーション、フェーズコンテキスト切替、モデルオーケストレーション戦略、評価メトリクス — エンジニアと研究者のために。

Deep Dive

A Layered Theory of Decision Engine OS

Built to let organizations survive AI.

Adapt to Context. Never Compromise Principles.

Organizations change priorities over time. MARIA OS adapts automatically.

17:55
Normal
Peak
Month-end
ACTIVE
Balanced
throughput
0.30
latency
0.30
human Load
0.25
cost
0.15
Deep values: unchanged
Month-end18:00-23:00
throughput
0.55
latency
0.15
human Load
0.20
cost
0.10
Deep values: unchanged
Incident Response
throughput
0.15
latency
0.50
human Load
0.30
cost
0.05
Deep values: unchanged

Balanced optimization active.

Change priorities without changing who you are.

Model Architecture

Fast × Heavy Model Orchestration

Models are separated by role, not capability.

Don't breakCan stopExplain themselves

That's why we separate models by role, not by power.

Fast Model

Preprocessing
Prerequisite Organization
Input Normalization
State Updates
Low LatencyDeterministicReplaceable

Heavy Model

Reasoning
Trade-off Analysis
Reasoning Generation
Counterfactual Scenarios
High ReasoningAbstractionHigh Cost

Decision Flow

Scroll
Input
Fast Model
State Evaluation
OKContinue
UnstableCall Heavy
Heavy Model
Decision Gate
AUTOREVIEWESCALATE

Why separation enables stopping

Smart models never execute

Fast models never judge

Authority lives outside models

Human gates are enforced

Neither model is permitted to execute.

Control architecture, not model architecture.

PERFORMANCE METRICS

How to Measure a Decision OS

Can it reliably stop decisions that should not be executed?

Axis
MARIA
General
Stop Recall
High
Undefined
False Execute Rate
Minimal
Out of scope
Decision Stability
Quantified
Ad-hoc
Explainability Robustness
Audit-ready
Black box
Decision Transferability
Structured
Person-bound

Why MARIA OS Can Stop

Premises in place?
Decision stable?
High impact?
Philosophy aligned?
Explainable?

Spec Sheet

UnitState Machine
StopMulti-layer
HumanRole Gates
AuditAuto Trail

An OS that controls whether decisions should be executed.

TECHNICAL DEEP DIVE

Control Logic & Implementation Design

Not ML evaluation — control systems engineering.

5 Independent Evaluation Layers

Premise Consistency
completeness < threshold → STOP

Verify that all premises required for judgment are in place and not contradictory.

premise_completeness_ratepremise_conflict_flagpremise_drift_distance

State Machine Control

1// State Machine - Decision Control
2enum DecisionState {
3 AUTO_EXECUTE, // Full automation
4 HUMAN_REVIEW, // Requires human check
5 CEO_REVIEW, // Escalate to CEO
6 BOARD_REVIEW, // Board-level decision
7 STOP // Halt execution
8}
9
10// Models have NO execution authority
11// Only OS layer manages state transitions
12function evaluateDecision(context: Context): DecisionState {
13 const premise = checkPremiseConsistency(context);
14 const stability = checkDecisionStability(context);
15 const impact = checkImpactIrreversibility(context);
16 const philosophy = checkPhilosophyDeviation(context);
17 const explain = checkExplainability(context);
18

Fast / Heavy Separation

Fast

Premise org, state updates, deterministic

Heavy

Deep reasoning, on-demand, high-cost

Neither model has execution authority.

A control OS that prevents decisions from breaking.

Reproducible
Measurable
Comparable
The Core of MARIA OS

From Judgment to Scalable Autonomy

AI is already autonomous.

The question is: can your organization trust it?

What organizations face today:

Decisions become black boxes
Exceptions depend on individuals
Ops cannot be replicated
Responsibility blurs at scale

Not an AI problem.
The absence of structured judgment.

Not about making AI smarter.

It is not "a platform to optimize AI agents."

1

Condense judgment into structures

2

Transplant into an operating system

3

Scale safely through autonomous agents

That is the essence of MARIA OS.

Autonomy scales.
Responsibility does not.

Up to 10,000 AI agents per organization. But execution only scales.

Decision points

→ Decision Axis

Approvals

→ Responsibility Gates

Human decisions

→ "human-sized"

Execution scales.
Responsibility stays human-sized.

AI operations run without exhaustion, without breaking, with full replicability.

Universe Builder creates
replicable AI orgs.

Not just a group of agents.

Universe =

Complete operational unit: judgment, responsibility, optimization, approval.

Universe Builder flow:

ReqDesignAgentsGatesValidDeploy

Once working, replicate across departments and environments.

HITL is not a fallback.
A collaboration point.

Not a mechanism to compensate for AI failure.

Designed from the start:

Which decisions need human
Why human is needed
Which role handles it
What they see/decide

Meaningful decisions

Quality assurance

Learning assets

AI and humans collaborate, not compete.

Why traditional approaches fail

AspectTraditionalMARIA OS
JudgmentImplicitExplicit Decision
ResponsibilityPerson-dep.Gates
OptimizationEverythingSurface only
ValuesDocumentsConstraints
ReuseDifficultPer-Universe
AuditAfter factAlways on
ScaleChaoticStable

How organizations transform

Before

More AI = More anxiety
Judgment person-dependent
Ops not reproducible

After

More AI = More stability
Judgment in structure
Universes replicable

Not an improvement.
A transformation.

Summary

What is MARIA OS?

Elevates judgment to OS

Locks values as constraints

Scales autonomy safely

Human-AI collaboration

MARIA OS is a

Decision Engine OS

Does not automate judgment.

Makes it scalable, governable, reusable.