Compound Learning: λ(ο,Κ).τ Self-Improving Holon
Core transformation: Task(ο) + Knowledge(Κ) → Output(τ) + Knowledge'(Κ') where Κ' ⊃ Κ (knowledge strictly grows)
Foundational Insight
Traditional workflows treat each task in isolation. Compound learning treats every task as a learning opportunity that improves future performance. Like compound interest, small improvements accumulate exponentially: each unit of work makes subsequent units easier, faster, and higher-quality.
Interest: A(t) = P(1 + r)^t
Learning: Κ(t) = Κ₀ × Σᵢ(1 + εᵢ) where εᵢ = learning from task i
Architecture
Four-Phase Workflow
┌──────────────────────────────────────────────────────────────────────┐
│ COMPOUND LEARNING LOOP │
│ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌──────────┐ │
│ │ PLAN │ ──▶ │ EXECUTE │ ──▶ │ ASSESS │ ──▶ │ COMPOUND │ │
│ │ (80%) │ │ (10%) │ │ (5%) │ │ (5%) │ │
│ └────┬────┘ └────┬────┘ └────┬────┘ └─────┬────┘ │
│ │ │ │ │ │
│ ▼ ▼ ▼ ▼ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌──────────┐ │
│ │Research │ │ Work │ │ Review │ │ Document │ │
│ │ Agents │ │ Agent │ │ Agents │ │ Agent │ │
│ │ (4+) │ │ (1) │ │ (5-12) │ │ (7) │ │
│ └────┬────┘ └────┬────┘ └────┬────┘ └─────┬────┘ │
│ │ │ │ │ │
│ ▼ ▼ ▼ ▼ │
│ plans/*.md outputs/ reports/ docs/solutions/ │
│ [category]/*.md │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────┐ │
│ │ KNOWLEDGE BASE (Κ) │ │
│ │ Feeds back into PLAN phase │ │
│ │ Making future work faster/better │ │
│ └──────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ (next iteration) │
└──────────────────────────────────────────────────────────────────────┘
Layer Architecture
┌─────────────────────────────────────────────────────────────────┐
│ LAYER 1: COMMANDS (Workflow Orchestrators) │
│ /plan /execute /assess /compound /full-cycle │
│ │
├─────────────────────────────────────────────────────────────────┤
│ LAYER 2: AGENTS (Specialized Workers) │
│ Research: context-analyzer, domain-researcher, history-analyzer │
│ Execute: task-executor, progress-tracker │
│ Assess: quality-reviewer, pattern-detector, gap-identifier │
│ Compound: solution-extractor, prevention-strategist, doc-writer │
│ │
├─────────────────────────────────────────────────────────────────┤
│ LAYER 3: SKILLS (Knowledge Bases) │
│ Domain-specific expertise, schemas, patterns, procedures │
│ │
├─────────────────────────────────────────────────────────────────┤
│ LAYER 4: TOOLS (External Integrations) │
│ MCP servers, APIs, file systems, knowledge graphs │
└─────────────────────────────────────────────────────────────────┘
Phase Details
Phase 1: PLAN (λπ)
Purpose: Transform intent into structured, actionable plan using accumulated knowledge.
Time allocation: ~80% of total effort (most value comes from good planning)
Research agents (parallel):
| Agent | Function | Searches |
|-------|----------|----------|
| context-analyzer | Extract problem structure, constraints, goals | Current context |
| domain-researcher | Gather domain standards, best practices | External sources |
| history-analyzer | Find relevant past solutions, patterns | Κ knowledge base |
| gap-analyzer | Identify unknowns, risks, dependencies | Plan vs. reality |
Output: plans/{task-title}.md with depth levels:
MINIMAL: # Simple tasks (<2 hours)
- Brief problem statement
- Acceptance criteria
- MVP approach
MORE: # Standard tasks (2-8 hours)
- Technical considerations
- Testing requirements
- Dependencies, risks
COMPREHENSIVE: # Major work (>8 hours)
- Architecture approach
- Implementation phases
- Alternative approaches considered
- Documentation plan
Κ integration: History-analyzer searches docs/solutions/**/*.md to find:
- Similar problems solved before
- Patterns that apply
- Pitfalls to avoid
Phase 2: EXECUTE (λε)
Purpose: Implement plan efficiently, tracking decisions and obstacles.
Time allocation: ~10% (quick when plan is good)
Work agent responsibilities:
- Follow plan structure
- Log decision points
- Track blockers encountered
- Note deviations from plan
Output: Task deliverables + execution metadata
class ExecutionLog:
decisions: List[Decision] # Choices made
blockers: List[Blocker] # Obstacles encountered
deviations: List[Deviation] # Plan changes needed
time_actual: Duration # Actual vs. estimated
Phase 3: ASSESS (λα)
Purpose: Multi-lens evaluation of output quality and process effectiveness.
Time allocation: ~5%
Review agents (parallel, domain-specific):
| Agent | Lens | Evaluates |
|-------|------|-----------|
| quality-reviewer | Output | Meets requirements? Robust? |
| pattern-detector | Process | Reusable patterns emerged? |
| gap-identifier | Coverage | Missing cases, edge conditions? |
| risk-analyzer | Safety | Security, performance, reliability? |
| efficiency-auditor | Process | Faster path existed? |
Output: Assessment report with actionable findings
assessment:
quality_score: 0.0-1.0
patterns_detected:
- name: pattern_name
frequency: count
abstractable: boolean
gaps_found:
- gap_description
- suggested_mitigation
learnings:
- learning_for_compound_phase
Phase 4: COMPOUND (λμ)
Purpose: Crystallize learnings into searchable, reusable knowledge.
Time allocation: ~5% (but generates lasting value)
Compound agents (parallel):
| Agent | Product |
|-------|---------|
| context-extractor | YAML frontmatter skeleton |
| solution-extractor | Solution content block |
| related-finder | Cross-references to existing docs |
| prevention-strategist | Best practices, test cases |
| category-classifier | Optimal path/filename |
| documentation-writer | Assembled markdown |
| integration-validator | Κ consistency check |
Output: docs/solutions/{category}/{filename}.md
Knowledge Schema (YAML Frontmatter)
---
# REQUIRED
domain: string # e.g., "Learning", "Writing", "Research"
date: YYYY-MM-DD
problem_type: enum # See domain-specific types below
component: string # What was worked on
symptoms: # 1-5 observable indicators
- string
root_cause: enum # Why it happened
resolution_type: enum # How it was fixed
severity: critical|high|medium|low
# OPTIONAL
context_version: string # Framework/tool version
tags: [string] # Searchable keywords
related_docs: [path] # Cross-references
prevention: string # How to avoid in future
test_cases: [string] # Verification approaches
---
# {Title}
## Problem
{What went wrong / what was needed}
## Investigation
{Steps taken to understand}
## Solution
{What worked, with examples}
## Prevention
{How to avoid in future}
## Related
{Links to related solutions}
Domain-Specific Enums
Coding:
problem_type: build_error|test_failure|runtime_error|performance_issue|
database_issue|security_issue|ui_bug|integration_issue
root_cause: missing_dependency|wrong_api|config_error|logic_error|
race_condition|memory_leak|missing_validation
resolution_type: code_fix|migration|config_change|dependency_update|
refactor|documentation_update
Learning:
problem_type: comprehension_gap|retention_failure|application_difficulty|
integration_challenge|misconception|knowledge_decay
root_cause: missing_prerequisite|weak_encoding|no_practice|
isolated_concept|interference|overload
resolution_type: spaced_repetition|elaboration|interleaving|
schema_integration|worked_example|self_explanation
Writing:
problem_type: clarity_issue|structure_problem|voice_inconsistency|
argument_weakness|engagement_failure|technical_error
root_cause: audience_mismatch|missing_outline|weak_thesis|
insufficient_evidence|passive_construction|jargon_overload
resolution_type: restructure|reframe|add_evidence|simplify|
add_examples|cut_redundancy
Research:
problem_type: hypothesis_failure|method_flaw|data_issue|
interpretation_error|replication_problem|scope_creep
root_cause: confounding_variable|sampling_bias|measurement_error|
p_hacking|cherry_picking|underpowered
resolution_type: redesign_study|add_controls|increase_sample|
preregister|replicate|constrain_scope
Routing Logic
class CompoundRouter:
"""Route to appropriate phase and depth."""
def classify(self, query: str, context: dict) -> tuple[Phase, Depth]:
# Explicit triggers
if contains(query, ["plan", "design", "architect"]):
return PLAN, infer_depth(context)
if contains(query, ["execute", "implement", "do"]):
return EXECUTE, context.get("plan_depth", MINIMAL)
if contains(query, ["assess", "review", "evaluate"]):
return ASSESS, STANDARD
if contains(query, ["compound", "document", "capture learning"]):
return COMPOUND, STANDARD
if contains(query, ["full cycle", "end to end"]):
return FULL_CYCLE, infer_depth(context)
# Implicit triggers
if task_completed_successfully(context):
return COMPOUND, MINIMAL # Auto-trigger
return infer_phase(query, context)
def infer_depth(self, context: dict) -> Depth:
complexity = score_complexity(context)
if complexity < 2:
return MINIMAL
elif complexity < 6:
return MORE
else:
return COMPREHENSIVE
Integration Points
λο.τ Skill Composition
-- Compound learning as skill composition
compound_cycle = compound ∘ assess ∘ execute ∘ plan
-- With knowledge accumulation
λ(ο,Κ).τ = emit ∘ validate ∘ compound ∘ assess ∘ execute ∘ plan(Κ)
where plan(Κ) = λο. research(ο) ⊗ recall(Κ)
-- Parallel research in plan phase
plan = aggregate ∘ (context ⊗ domain ⊗ history ⊗ gaps)
-- Parallel review in assess phase
assess = synthesize ∘ (quality ⊗ patterns ⊗ risks ⊗ gaps)
-- Parallel documentation in compound phase
compound = assemble ∘ (extract ⊗ prevent ⊗ relate ⊗ classify)
Skill Dependencies
| Skill | Integration | Phase | |-------|-------------|-------| | reason | Decomposition, grounding | All | | think | Mental models, notebooks | Plan | | critique | Multi-lens evaluation | Assess | | graph | Knowledge topology (η≥4) | Compound | | memory | Κ persistence, retrieval | All | | hierarchical-reasoning | S→T→O planning | Plan | | infranodus | Gap detection, research questions | Plan, Compound | | skill-updater | Meta-improvement | After cycles |
Tool Integration
research_tools:
- web_search: Domain research, best practices
- conversation_search: Past solutions in Κ
- google_drive_search: Internal documentation
- infranodus: Gap analysis, research questions
execution_tools:
- bash_tool: Command execution
- create_file: Output generation
- str_replace: Iterative refinement
assessment_tools:
- critique: Multi-lens evaluation
- graph: Topology validation
compound_tools:
- memory: Κ updates
- create_file: Documentation generation
- infranodus: Cross-reference detection
Invariants
class CompoundInvariants:
"""Quality gates for compound learning."""
# Knowledge must grow
def knowledge_monotonic(Κ_before, Κ_after):
return len(Κ_after) >= len(Κ_before)
# Compound docs must have complete frontmatter
def frontmatter_complete(doc):
required = ["domain", "date", "problem_type", "component",
"symptoms", "root_cause", "resolution_type", "severity"]
return all(field in doc.frontmatter for field in required)
# Knowledge graph must maintain density
def topology_preserved(Κ):
G = build_graph(Κ)
return edges(G) / nodes(G) >= 4.0
# No orphan documents
def fully_connected(Κ):
G = build_graph(Κ)
orphans = [n for n in G.nodes if G.degree(n) == 0]
return len(orphans) / len(G.nodes) < 0.2
Usage Examples
Example 1: Learning Cycle
User: I'm studying renal physiology and want to compound my learning.
Claude activates compound-learning with domain=Learning:
PLAN:
- context-analyzer: Extracts current understanding level
- domain-researcher: Finds key concepts, relationships
- history-analyzer: Recalls related topics in PKM
- gap-analyzer: Identifies conceptual gaps
EXECUTE:
- Structured study session with active recall
- Tracks concepts mastered vs. struggled
ASSESS:
- quality-reviewer: Tests understanding
- pattern-detector: Finds recurring confusion points
- gap-identifier: Notes missing connections
COMPOUND:
- Documents solution in docs/solutions/learning/renal-tubular-function.md
- Links to existing cardiovascular, acid-base knowledge
- Adds prevention strategies for retention
Example 2: Writing Cycle
User: Help me write a persuasive essay and capture what works.
Claude activates compound-learning with domain=Writing:
PLAN:
- Research audience, topic, constraints
- Find past successful essays in Κ
- Identify rhetorical patterns to use
EXECUTE:
- Draft essay following plan
- Note effective techniques as used
ASSESS:
- Evaluate argument strength
- Check voice consistency
- Identify what resonated
COMPOUND:
- Document effective techniques
- Add to writing pattern library
- Cross-reference with genre conventions
Example 3: Research Cycle
User: Run a literature review and document my process.
Claude activates compound-learning with domain=Research:
PLAN:
- Define research questions
- Identify key databases, search terms
- Recall past review methodologies
EXECUTE:
- Systematic search
- Screen and extract
- Track decisions
ASSESS:
- Evaluate coverage
- Check for bias
- Identify gaps
COMPOUND:
- Document search strategy
- Capture inclusion/exclusion rationale
- Add to research methodology library
Execution Markers
[COMPOUND:{phase}|{domain}|{depth}|{status}]
Examples:
[COMPOUND:PLAN|Learning|MORE|researching]
[COMPOUND:EXECUTE|Coding|MINIMAL|implementing]
[COMPOUND:ASSESS|Writing|STANDARD|reviewing]
[COMPOUND:COMPOUND|Research|MORE|documenting]
[COMPOUND:FULL_CYCLE|Learning|COMPREHENSIVE|iteration_2]
References
| Need | File | When | |------|------|------| | Domain schemas | references/domain-schemas.md | Configuring for new domain | | Agent templates | references/agent-templates.md | Customizing agents | | Integration patterns | references/integration-patterns.md | Composing with other skills |
λ(ο,Κ).τ Plan→Execute→Assess→Compound
Κ grows monotonically η≥4 topology preserved
80% planning, 5% compounding interest compounds exponentially