recursive-systems-architect

name	recursive-systems-architect
description	Designs self-referential and recursive systems that examine, modify, or generate themselves, including metacognitive architectures and strange loops.
license	MIT

Recursive Systems Architect

This skill provides guidance for designing systems that operate on themselves—self-referential structures, metacognitive architectures, and recursive processes that create emergent properties through strange loops.

Core Competencies

• Self-Reference: Systems that examine or modify themselves
• Strange Loops: Hierarchical tangles where levels fold back
• Metacognition: Systems that reason about their own reasoning
• Fixed Points: Stable states in recursive processes
• Emergence: Properties arising from recursive interaction

Foundations of Recursive Systems

What Makes a System Recursive

Traditional System:              Recursive System:
Input → Process → Output         Input → Process → Output
                                         ↑         │
                                         └─────────┘
                                    Process operates on
                                    itself or its outputs

Types of Self-Reference

Type	Description	Example
Direct	System references itself explicitly	function f() { return f; }
Indirect	System references itself via another	A references B, B references A
Hierarchical	Higher level describes lower level	Metadata about data
Strange Loop	Levels fold back unexpectedly	Gödel sentences

The Strange Loop Pattern

Douglas Hofstadter's concept: moving through levels of a hierarchy, you unexpectedly find yourself back where you started.

Level 3: Meta-rules (rules about rules)
    ↑                    │
Level 2: Rules           │
    ↑                    │
Level 1: Objects         │
    ↑                    ↓
    └────────────────────┘
    Level 3 can modify Level 1,
    which affects what reaches Level 3

Recursive Architecture Patterns

Self-Modifying Code

# System that modifies its own behavior
class SelfModifyingAgent:
    def __init__(self):
        self.rules = {
            'default': lambda x: x * 2
        }
        self.meta_rules = {
            'optimize': self._optimize_rules
        }

    def process(self, input):
        result = self.rules['default'](input)
        # System examines its own performance
        self._reflect_on_result(result)
        return result

    def _reflect_on_result(self, result):
        # Meta-level: decide whether to modify rules
        if self._should_modify():
            self.meta_rules['optimize']()

    def _optimize_rules(self):
        # Modify the rule that produced the result
        # This is the recursive fold-back
        self.rules['default'] = self._generate_better_rule()

Metacognitive Loop

┌─────────────────────────────────────────────────────────┐
│                  Metacognitive Architecture              │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  ┌─────────────────────────────────────────────┐       │
│  │           Meta-Cognitive Layer               │       │
│  │  • Monitor cognitive processes               │       │
│  │  • Evaluate strategy effectiveness           │       │
│  │  • Modify cognitive strategies               │       │
│  └──────────────────┬──────────────────────────┘       │
│                     │ observes & modifies               │
│                     ▼                                   │
│  ┌─────────────────────────────────────────────┐       │
│  │           Cognitive Layer                    │       │
│  │  • Execute reasoning strategies              │       │
│  │  • Process information                       │       │
│  │  • Generate outputs                          │       │
│  └──────────────────┬──────────────────────────┘       │
│                     │ produces                          │
│                     ▼                                   │
│  ┌─────────────────────────────────────────────┐       │
│  │           Ground Layer                       │       │
│  │  • Raw inputs and outputs                    │       │
│  │  • Environmental interaction                 │       │
│  └─────────────────────────────────────────────┘       │
│                                                         │
└─────────────────────────────────────────────────────────┘

Fixed Point Iteration

Many recursive systems seek fixed points—states where further iteration produces no change:

def find_fixed_point(f, initial, tolerance=1e-6, max_iter=1000):
    """Find x where f(x) = x"""
    x = initial
    for i in range(max_iter):
        x_next = f(x)
        if abs(x_next - x) < tolerance:
            return x_next  # Fixed point found
        x = x_next
    return x  # May not have converged

# Self-consistent beliefs example
def belief_update(beliefs):
    """Update beliefs based on other beliefs"""
    new_beliefs = {}
    for key, value in beliefs.items():
        # Each belief influenced by related beliefs
        related = get_related_beliefs(beliefs, key)
        new_beliefs[key] = aggregate(value, related)
    return new_beliefs

# Find equilibrium beliefs
stable_beliefs = find_fixed_point(belief_update, initial_beliefs)

Quine Pattern (Self-Reproduction)

A quine is a program that outputs its own source code:

# Python quine
s = 's = %r\nprint(s %% s)'
print(s % s)

This pattern extends to systems that can describe or reconstruct themselves:

class SelfDescribingSystem:
    """System that can generate its own specification"""

    def __init__(self, config):
        self.config = config
        self.state = {}

    def describe(self):
        """Generate a complete description of this system"""
        return {
            'type': self.__class__.__name__,
            'config': self.config,
            'state': self.state,
            'methods': self._describe_methods()
        }

    def reconstruct(self, description):
        """Create a new instance from description"""
        return self.__class__(description['config'])

    def clone(self):
        """Self-reproduction via self-description"""
        description = self.describe()
        return self.reconstruct(description)

Recursive System Design Patterns

Observer-Observed Duality

class ReflectiveSystem:
    """System that is both observer and observed"""

    def __init__(self):
        self.observations = []
        self.self_model = {}

    def act(self, action):
        # Perform action
        result = self._execute(action)

        # Observe self performing action
        self._observe_self(action, result)

        # Update self-model based on observation
        self._update_self_model()

        return result

    def _observe_self(self, action, result):
        observation = {
            'action': action,
            'result': result,
            'predicted': self.self_model.get('predicted_result'),
            'surprise': self._compute_surprise()
        }
        self.observations.append(observation)

    def _update_self_model(self):
        # Self-model predicts own behavior
        # Discrepancies drive model updates
        recent = self.observations[-10:]
        self.self_model['patterns'] = self._find_patterns(recent)
        self.self_model['predicted_result'] = self._predict_next()

Recursive Decomposition

Break problems into self-similar sub-problems:

def recursive_solve(problem, depth=0, max_depth=10):
    """Solve by recursive decomposition"""

    # Base case: problem is atomic
    if is_atomic(problem) or depth >= max_depth:
        return solve_directly(problem)

    # Recursive case: decompose and solve
    subproblems = decompose(problem)
    subsolutions = [recursive_solve(sp, depth + 1) for sp in subproblems]

    # Combine subsolutions
    solution = combine(subsolutions)

    # Meta-level: evaluate solution quality
    if not satisfactory(solution, problem):
        # Try different decomposition
        alternative = alternative_decomposition(problem)
        return recursive_solve(alternative, depth)

    return solution

Self-Referential Data Structures

class RecursiveNode:
    """Node that can contain references to itself"""

    def __init__(self, value):
        self.value = value
        self.children = []
        self.references = []  # Can include self

    def add_self_reference(self):
        """Create a strange loop"""
        self.references.append(self)

    def traverse(self, visited=None):
        """Traverse handling cycles"""
        if visited is None:
            visited = set()

        if id(self) in visited:
            return ['(cycle detected)']

        visited.add(id(self))
        result = [self.value]

        for child in self.children:
            result.extend(child.traverse(visited))

        return result

Emergence from Recursion

Cellular Automata Pattern

Simple rules + self-application = complex behavior:

def cellular_automaton(rule, initial_state, generations):
    """
    Rule: function mapping neighborhood to next state
    Self-reference: each cell depends on neighbors who depend on it
    """
    state = initial_state
    history = [state]

    for _ in range(generations):
        new_state = []
        for i in range(len(state)):
            # Each cell's next state depends on neighborhood
            # The rule is applied uniformly—the recursion creates complexity
            neighborhood = get_neighborhood(state, i)
            new_state.append(rule(neighborhood))
        state = new_state
        history.append(state)

    return history

Self-Organizing Criticality

Systems that naturally evolve toward critical states:

class SandpileModel:
    """System that self-organizes to critical state"""

    def __init__(self, size, threshold=4):
        self.grid = [[0] * size for _ in range(size)]
        self.threshold = threshold

    def add_grain(self, x, y):
        self.grid[x][y] += 1
        self._maybe_topple(x, y)

    def _maybe_topple(self, x, y):
        """Recursive toppling creates power-law distributions"""
        if self.grid[x][y] >= self.threshold:
            self.grid[x][y] -= self.threshold
            # Distribute to neighbors—may trigger their toppling
            for nx, ny in self._neighbors(x, y):
                self.grid[nx][ny] += 1
                self._maybe_topple(nx, ny)  # Recursive!

Design Principles

Termination Guarantees

Recursive systems must handle infinite loops:

1. Depth limits: Maximum recursion depth
2. Change detection: Stop when fixed point reached
3. Energy/resource bounds: Limited computation budget
4. Cycle detection: Track visited states

Coherence Maintenance

Self-modifying systems risk incoherence:

1. Invariant preservation: Core properties never violated
2. Gradual change: Small modifications only
3. Rollback capability: Undo harmful changes
4. Sandboxing: Test modifications before applying

Observability

Recursive systems are hard to debug:

1. Level tagging: Track which meta-level produced output
2. Trace logging: Record the recursion path
3. State snapshots: Capture intermediate states
4. Visualization: Render the strange loop structure

References

• references/strange-loops.md - Hofstadter's strange loop theory
• references/fixed-point-theory.md - Mathematical foundations
• references/metacognitive-patterns.md - Metacognition implementation patterns