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)
| Scale | Renormalization Action | Universality Class | |-------|------------------------|-------------------| | Config | Consolidate routers (15 -> 7) | Delegation pattern | | Skill | Merge duplicate content | lambda.o.tau triad | | Agent | Domain agents absorb specialists | Execution pattern | | File | Deduplicate sections | Frontmatter schema |
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)
| Agent | Model | Complexity | Use When | |-------|-------|------------|----------| | sisyphus-junior | Sonnet | 0.4-0.7 | Focused task execution, implementation | | explore | Haiku | 0.1-0.3 | Pattern matching, file discovery, quick search | | oracle | Opus | 0.7-1.0 | Root cause analysis, architecture decisions | | engineer | Sonnet | 0.5-0.8 | Production-ready implementation |
Tier 2: Medium-Frequency (15% of delegations)
| Agent | Model | Complexity | Use When | |-------|-------|------------|----------| | librarian | Sonnet | 0.3-0.5 | Documentation research, codebase understanding | | architect | Opus | 0.8-1.0 | System design, multi-domain decomposition | | prometheus | Sonnet | 0.5-0.7 | Strategic planning, roadmap design | | researcher | Sonnet | 0.4-0.6 | Deep research with MCP tools |
Tier 3: Low-Frequency (5% of delegations)
| Agent | Model | Complexity | Use When | |-------|-------|------------|----------| | document-writer | Haiku | 0.2-0.4 | README, API docs, technical writing | | multimodal-looker | Sonnet | 0.3-0.5 | Screenshots, diagrams, visual analysis | | momus | Haiku | 0.3-0.5 | Critical plan review, devil's advocate | | metis | Sonnet | 0.4-0.6 | Pre-planning, hidden requirements | | frontend-engineer | Sonnet | 0.4-0.7 | UI/UX, components, styling |
External CLI Agents (Token Conservation)
| Agent | Binary | Context Limit | Use When | |-------|--------|---------------|----------| | gemini | /opt/homebrew/bin/gemini | 2M tokens | Large context analysis (>100K) | | codex | ~/.local/bin/codex | 128K tokens | GPT code generation preference | | amp | ~/.amp/bin/amp | 200K tokens | Claude-specific delegation |
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
| Pipeline | Threshold | Use When | |----------|-----------|----------| | R1 (Simple) | 0.85 | Single-domain, <10 files | | R2 (Moderate) | 0.92 | Multi-domain, 10-50 files | | R3 (Complex) | 0.96 | Architecture-level, >50 files |
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
| Invariant | Expression | Enforcement | |-----------|------------|-------------| | K-monotonicity | len(K') >= len(K) | Never delete knowledge | | Topology | eta >= 4 | Minimum connectivity maintained | | Homoiconicity | Sigma.can_process(Sigma) | Self-referential capability | | Scale Invariance | structure(L_n) cong structure(L_{n+1}) | Same patterns at all levels | | Power Law | P(k) ~ k^{-alpha} | 80/20 resource allocation |
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