Robust-First

"Survive first. Be correct later."

What Is It?

Robust-First is Dave Ackley's principle: systems should prioritize survivability over correctness.

A system that crashes when confused is useless. A system that limps along incorrectly but keeps running can be repaired.

The Philosophy

Traditional computing:

code

IF error THEN crash
"Fail fast and loud"

Robust-first computing:

code

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

Core Principles

1. Never Crash

yaml

# 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:

yaml

# 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:

yaml

# 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:

yaml

# 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:

yaml

# 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

yaml

# 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

code

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