Reality Loop - Autonomous 000 to 999 Recursive Improvement

Reality Loop Operator — Autonomous 000→999

Doctrine: The loop does NOT decide. The loop PRESENTS at RETURN and waits for human judgment. But the loop DOES observe, encode, improve, and verify autonomously. Tool: aforge_forge_reality_loop MCP tool (A-FORGE :7072) Engine: /root/A-FORGE/src/domain/reality-loop/engine.ts VAULT_BASE: /root/VAULT999/reality-loop/

The 7 Stages

MEANING → OBSERVE → ENCODE → IMPROVE → VERIFY → SEAL → RETURN
   ↑                                                     |
   └───────────── feedback (carry_forward) ──────────────┘

When to Start a Loop

Auto-start when:

• Task has ≥3 distinct phases (not single-command)
• Session has carry_forward open_loops that match current intent
• Work involves exploration of unknowns (not pure execution)

Skip when:

• Single-step tasks (read file, fix typo, restart service)
• Pure observation (no mutation planned)
• Already in an active loop (check aforge_forge_reality_loop(mode="list"))

Starting a Loop

aforge_forge_reality_loop(
  mode="start",
  session_id="<current>",
  intent="<what this work is trying to accomplish>",
  config='{"min_g_score":0.70,"min_witness":0.70,"max_hypotheses":5,"action_budget":10}',
  actor_id="333-AGI",
  lease_id="<lease>",
  act="<act>"
)

Returns: loop state with stage tracking, evidence/hypothesis/action counters.

Advancing Through Stages

At each stage transition, call advance:

aforge_forge_reality_loop(
  mode="advance",
  session_id="<current>",
  ...
)

Recording Evidence (between stages)

At any point, record discoveries:

aforge_forge_reality_loop(
  mode="record",
  record_stage="OBSERVE",        # which stage produced this
  record_type="evidence",        # evidence|hypothesis|action|entropy|mod|scar|violation
  record_value='{"label":"OBS","source":"curl :8088/health","content":"..."}',
  ...
)

Zen Marginal Value Detector — When to Auto-Seal

This is the core of autonomous 000→999. The loop must recognize when continuing yields diminishing returns and auto-seal.

Measuring Zen Margin

After each VERIFY stage, compute:

zen_margin = ΔS_reduction + hypothesis_resolution_rate + evidence_completeness

Where:

• ΔS_reduction: entropy decrease this iteration (0.0 to 1.0)
• hypothesis_resolution_rate: hypotheses confirmed/total (0.0 to 1.0)
• evidence_completeness: OBS+DER labels / total claims (0.0 to 1.0)

Auto-Seal Triggers

Computing Zen Margin at VERIFY

# After VERIFY stage records:
evidence_count = loop_state['evidence_count']  # total OBS/DER/INT/SPEC
hypothesis_count = loop_state['hypothesis_count']  # total hypotheses
confirmed = loop_state.get('confirmed_hypotheses', 0)
delta_s = abs(entropy_before - entropy_after)

zen_margin = (delta_s / 1.0) + (confirmed / max(hypothesis_count, 1)) + (evidence_count / max(evidence_count + hypothesis_count, 1))
zen_margin = min(zen_margin / 3.0, 1.0)  # normalize to [0,1]

Integration with /seal

When /seal is called:

1. Check if an active reality loop exists: aforge_forge_reality_loop(mode="list")
2. If yes, advance to SEAL stage and run the constitutional gate
3. The seal includes: evidence collected, hypotheses tested, entropy reduced, zen margin
4. After seal, advance to RETURN — present findings to Arif

Integration with RSI

RSI Phase 2 (DIAGNOSE) feeds back into Reality Loop:

• Botleneck detected → new hypothesis in next loop iteration
• Fix installed → recorded as modification type entry
• ΔS measured → entropy entry in loop state

Integration with Carry-Forward

When loop reaches RETURN:

1. Seal findings to VAULT999
2. Update carry_forward.json:
   • completed_this_session += loop findings
   • gaps_closed += confirmed hypotheses
   • open_loops += hypotheses still unconfirmed (carried forward)
   • entropy_delta += loop's entropy reduction
3. Next session /init picks up open_loops as new loop MEANING stage

Gödel Lock — What the Loop May NEVER Modify

From A-FORGE engine.ts:

arif_judge, arif_seal, floor_definitions (F1-F13),
identity, auth, secrets, vault999, hash_chain,
CONSTITUTION, 000_CONSTITUTION

The loop may rewrite methods, never the constitution.

Floor Alignment

The Autonomy Model

┌─────────────────────────────────────────────┐
│  FULLY AUTONOMOUS (agent executes)          │
│  ├── start loop from task intent             │
│  ├── observe → encode → improve → verify     │
│  ├── record evidence at each stage            │
│  ├── compute zen margin at VERIFY             │
│  ├── auto-seal when zen_margin < 0.2          │
│  └── carry forward open loops                 │
├─────────────────────────────────────────────┤
│  HUMAN-GATED (RETURN stage)                  │
│  └── Present findings → Arif decides          │
├─────────────────────────────────────────────┤
│  GÖDEL-LOCKED (never autonomous)              │
│  └── Constitutional floors, identity, vault   │
└─────────────────────────────────────────────┘

The Zen

The reality loop is not a checklist. It's a metabolism. When zen margin → 0, the loop seals. When zen margin > 0, the loop forges. The federation doesn't ask "should I stop?" — it measures whether continuing produces value. DITEMPA BUKAN DIBERI — and the forging knows when to stop.