Traditional computing:

IF error THEN crash
"Fail fast and loud"

Robust-first computing:

IF error THEN repair_locally AND continue
"Stay alive and heal"

Core Principles

1. Never Crash

# WRONG
if missing_field:
    raise Error("Field required!")
    
# RIGHT  
if missing_field:
    log_warning("Field missing, using default")
    field = reasonable_default

2. Local Repair

Don't wait for global consistency. Fix what you can, where you are:

# Found inconsistency
character.location: room-A
room-A.occupants: [not including character]

# Local repair
room-A.occupants.append(character)
log: "Repaired: added character to room-A occupants"

3. Degrade Gracefully

When resources are limited, do less but keep working:

# Full capability
- semantic search
- syntax highlighting  
- auto-complete
- error detection

# Degraded (low memory)
- basic search only
- plain text
- manual completion
- errors on save only

4. Redundancy

Important state exists in multiple places:

# Character location recorded in:
- character.yml → location field
- room/ROOM.yml → occupants list
- session-log.md → movement events

# If one is corrupted, recover from others

The Movable Feast Machine

Dave Ackley's Movable Feast Machine (MFM):

Computation spread across unreliable substrate
No global clock, no central control
Elements repair themselves and neighbors
Errors are normal, not exceptional

MOOLLM inherits this:

Files can be corrupted — repair from redundancy
Schemas can drift — reconcile gracefully
Context can overflow — summarize and continue
Tools can fail — retry or work around

Anti-Fragility

Beyond robust — anti-fragile:

Fragile	Robust	Anti-Fragile
Breaks under stress	Survives stress	Gets stronger from stress
Crash on error	Handle error	Learn from error
Rigid schema	Flexible schema	Schema evolves from errors

When something goes wrong, capture the lesson:

# Error occurred
repair_log:
  - issue: "Character teleported without movement event"
    repair: "Added movement event retroactively"
    lesson: "Always log movements before updating location"
    
# Next time: system knows to check this

MOOLLM Application

Self-Repair Demon

A background process that:

Scans for inconsistencies
Attempts local repairs
Logs what it fixed
Escalates what it couldn't

See: self-repair/

POSTEL for Errors

When encountering malformed input:

Try to parse anyway
Infer missing parts
Flag assumptions
Continue working

See: postel/

Never Delete

Instead of deleting, archive:

Corrupted files → .archive/corrupted/
Old versions → .archive/versions/
Failed attempts → .archive/failed/

Recovery is always possible.

Example: Corrupted Room

# room/ROOM.yml has parse error

Traditional response:
  "Error: Invalid YAML at line 42"
  [System halts]

Robust-first response:
  "Warning: ROOM.yml has syntax error"
  "Attempting recovery..."
  "- Loaded last known good state from git"
  "- Merged recent changes from session-log.md"
  "- Flagged line 42 for manual review"
  [System continues with recovered state]

Dovetails With

Sister Skills

self-repair/ — Checklist-based healing
postel/ — Charitable interpretation

Kernel

kernel/self-healing-protocol.md — Full specification

Protocol Symbols

ROBUST-FIRST   — Survive over correct
NEVER-CRASH    — Always keep running
REPAIR-DEMON   — Background fixer
BEST-EFFORT    — Do what you can
NEVER-DELETE   — Archive, don't destroy

See: PROTOCOLS.yml

robust-first

Robust-First

What Is It?

The Philosophy