Ultrawork

G_meta(lambda, Kappa, Sigma).tau' -- Orchestrate at all scales, compound gains exponentially.

Navigation

Concepts: scale-invariance, metagraph, homoiconicity, pareto-governance, convergence

Integration: delegate-router, learn, ARCHITECTURE

Metasuperhypergraph Architecture

Level 0 (Sigma):     Entire Claude Config (self-referential schema)
Level 1 (G_meta):    Skills + Routers + Agents (hyperedges connecting triads)
Level 2 (G):         Individual component files
Level 3 (V):         Sections within files (frontmatter, body, graph)
Level 4 (v):         Individual properties/concepts

                    SCALE INVARIANCE
    structure(Level_n) ≅ structure(Level_{n+1}) ≅ lambda.o.tau

Core Principles

1. Renormalization Group Optimization

Apply the same optimization at each scale level:

def renormalize(G_level):
    """Coarse-grain, identify universality class, extract relevant operators."""
    # Identify redundant patterns
    redundant = find_duplicates(G_level)
    # Merge into canonical forms
    canonical = merge_to_canonical(redundant)
    # Project to lower-dimension effective theory
    return project(canonical, dim=relevant_operators_only)

2. Power Law Resource Allocation (Pareto)

P(k) ~ k^{-alpha}  where alpha approx 2.5

Top 20% of agents handle 80% of tasks:
  oracle, sisyphus-junior, explore, engineer (4/20 = 20%)

Top 20% of skills deliver 80% of value:
  learn, ultrawork, git-master, lambda-skill, obsidian (5/23 approx 22%)

3. Homoiconic Self-Improvement

# Ultrawork can improve itself
assert ultrawork.can_process(ultrawork.schema) == True

def self_improve(skill):
    analysis = skill.analyze(skill.schema)
    improvements = skill.generate_improvements(analysis)
    validated = skill.validate(improvements)
    return skill.apply(validated) if validated else skill

Agent Routing Matrix (Power-Law Optimized)

Tier 1: High-Frequency (80% of delegations)

Tier 2: Medium-Frequency (15% of delegations)

Tier 3: Low-Frequency (5% of delegations)

External CLI Agents (Token Conservation)

Execution Patterns

Parallel Execution (Independent Tasks)

# Launch simultaneously in single message
spawn:
  - Task(explore, "find auth files", run_in_background: true)
  - Task(librarian, "search auth docs", run_in_background: true)
  - Task(researcher, "find auth best practices", run_in_background: true)
collect: TaskOutput for each
merge: Deduplicate by content hash

Sequential Execution (Dependent Tasks)

# Chain with explicit dependencies
pipeline:
  - result_1 = Task(explore, "find relevant code")
  - result_2 = Task(oracle, "analyze: ${result_1}")
  - result_3 = Task(engineer, "implement fix: ${result_2}")

Background Execution (Long-Running)

background_operations:
  - Package installation: npm install, pip install, cargo build
  - Build processes: npm run build, make, tsc
  - Test suites: npm test, pytest, cargo test
  - Docker operations: docker build, docker pull
  - Large file operations: >1000 files
  - Subagent delegations: complexity > 0.7

foreground_operations:
  - Quick status: git status, ls, pwd (<5s)
  - File reads/edits
  - Simple commands
  - Verification checks

Convergence Detection

Fixed-Point Termination

def at_fixed_point(state, epsilon=0.001):
    """Detect when further iteration yields no improvement."""
    new_state = iterate(state)
    return distance(state, new_state) < epsilon

def ultrawork_loop(task):
    state = initialize(task)
    while not at_fixed_point(state):
        state = parallel_execute(state)
        state = assess(state)
        if converged(state):
            break
    return finalize(state)

Convergence Thresholds

Verification Checklist (Invariants)

Before stopping, ALL must be true:

• TODO LIST: Zero pending/in_progress tasks
• FUNCTIONALITY: All requested features work
• TESTS: All tests pass (if applicable)
• ERRORS: Zero unaddressed errors
• TOPOLOGY: eta >= 4 (if knowledge graph modified)
• MONOTONICITY: len(K') >= len(K) (no knowledge lost)

If ANY checkbox is unchecked, CONTINUE WORKING.

Integration with Learn Skill

Ultrawork extends learn with:

-- Learn: Sequential knowledge compounding
lambda(o, K, Sigma).tau' = renormalize . compound . assess . execute . route . parse

-- Ultrawork: Parallel orchestration with scale invariance
G_meta(lambda, K, Sigma).tau' = parallelize . delegate . renormalize . compound

Post-Task Learning Loop

after_completion:
  - Extract learnings via learn skill
  - Crystallize patterns with vertex-sharing
  - Update knowledge graph (K -> K')
  - If schema improvement identified: propose to user

Invariants Preserved

Quick Reference

G_meta(lambda,K,Sigma).tau'   Parallelize -> Delegate -> Renormalize -> Compound
K grows                       Sigma evolves              eta>=4 preserved
Scale-invariant               Power-law optimized        Fixed-point convergent