Ideate

Customization

Before executing, check for user customizations at: ~/.claude/PAI/USER/SKILLCUSTOMIZATIONS/Ideate/

Ideate — The Cognitive Progress Engine

A loop-controlled evolutionary creativity engine that mirrors human cognitive processes to generate genuinely novel ideas. This is NOT BeCreative — BeCreative is a single-pass diversity tool. Ideate is an evolutionary system: multiple cycles of consuming, dreaming, stealing, breeding, and testing ideas over simulated time scales from hours to decades, driven by a first-class Loop Controller and a Lamarckian Meta-Learner.

The Core Insight

Human creativity reduces to 5 irreducible functions:

The 9 workflow phases expand these into a richer human-legible system. DREAM, DAYDREAM, and CONTEMPLATE are PERTURB at different noise levels. MATE is PERTURB on existing ideas. META-LEARN adds the Lamarckian advantage — analyzing WHY ideas worked and steering future generation.

The 9 Phases (Summary)

Post-loop: The Historian runs the Insight Extractor for cross-cycle pattern analysis.

Full phase mechanics live in Workflows/FullCycle.md.

Workflow Routing

The Loop Controller

Owns inter-cycle state and makes continue/pivot/stop decisions after each cycle's META-LEARN phase. State tracked:

{
  "cycle_count": 0,
  "max_cycles": null,
  "budget_seconds_remaining": 600,
  "fitness_history": [{"cycle": 1, "avg_score": 52.3, "top_score": 68.1, "diversity_index": 0.91}],
  "stagnation_counter": 0,
  "strategy_version": 1,
  "strategy_adjustments": {},
  "loop_decision_log": []
}

Loop Gate logic:

IF budget_seconds_remaining <= 0:        STOP (budget exhausted)
ELIF stagnation_counter >= 3:
    IF strategy_pivots_remaining > 0:    PIVOT (shift domains/noise/agents)
    ELSE:                                STOP (exhausted strategies)
ELIF diversity_index < 0.3:              PIVOT (collapse — inject immigrants)
ELIF top_score >= target_score:          STOP (target reached)
ELSE:                                    CONTINUE

Structural Randomness Engine

LLM "temperature" is soft probability redistribution biased toward the training distribution. Ideate uses structural randomness at the data level instead:

• Input subsetting (DREAM): Fisher-Yates shuffle picks each agent's input subset
• Domain lottery (STEAL): weighted random sampling from the 50+ candidate domain pool
• Pairing shuffle (MATE): Fisher-Yates pairs adjacent items; 20% slots forced cross-phase
• Mutation dice (EVOLVE): roll an 8-sided die, apply that mutation operation:

1. Flip one assumption 2. Invert the constraint 3. Change the scale (10× bigger or smaller) 4. Change the time horizon 5. Merge with a random killed idea's best element 6. Apply a constraint from a random domain 7. Remove the most complex component 8. Add an adversarial requirement

Implementation: crypto.getRandomValues() with seed = cycle number + problem hash.

External Validation Hooks (TEST extension)

Optional pluggable interface that adds real-world signal to internal scoring:

interface ValidationHook {
  name: string;
  validate(idea: Idea, problem: Problem): Promise<{ modifier: number; evidence: string }>;
}

Built-in hooks: MarketSearch (existing implementations), FeasibilityCheck (technical blockers), ExpertPanel (async human review), PrototypeSimulation (generate + test prototype).

Time-Scale Configuration

Loop Controller decides actual cycle count adaptively, not a fixed count.

State Persistence

Each run persists to ~/.claude/PAI/MEMORY/WORK/{slug}/ideate/:

ideate/
  config.json           # Problem, time_scale, domains, hooks
  loop-state.json       # Loop Controller (fitness_history, strategy, decisions)
  domain-pool.json      # Weighted domain pool (expanded across cycles)
  cycle-NNN/            # Per-cycle artifacts: input-pool, dreams, daydreams,
                        # analyses, checkpoint-a, stolen, offspring, scores,
                        # checkpoint-b, survivors, meta-learning, summary
  insights.md           # Insight Extractor output (post-loop)
  final-output.md       # Ranked candidate list with full provenance

Idea Data Structure

{
  "id": "idea-042",
  "text": "...",
  "provenance": {
    "parents": ["idea-017", "idea-023"],
    "operation": "crossover",
    "mutation_type": "scale_change",
    "mutation_die_roll": 3,
    "cycle": 3, "phase": "MATE",
    "source_domains": ["mycology", "distributed-systems"],
    "randomness_seed": "a7f3c9..."
  },
  "scores": {
    "feasibility": 72, "novelty": 88, "impact": 65, "elegance": 81,
    "composite": 76.5, "confidence": 0.82, "judge_variance": 8.3,
    "external_validation": {"market_search": {"modifier": -5, "evidence": "..."}},
    "adjusted_composite": 74.5
  },
  "arguments": {"supporting": "...", "counter": "..."}
}

Final Output Format

# Ideate Results: [Problem]

**Time scale:** [scale] | **Budget used:** X of Y min | **Cycles:** N (adaptive)
**Strategy pivots:** M | **Total ideas:** X | **Survived:** Y | **Kill rate:** Z%

## Top Candidates (ranked by adjusted composite score)

### 1. [Title] — Score: 85.2/100 (confidence: 0.91)

**The idea:** [2-3 sentences]
**Scores:** Feasibility: 78 | Novelty: 92 | Impact: 84 | Elegance: 87
**External validation:** [hook results]
**Provenance:** Born in cycle N from [operation] of [parents]. Mutation: [type].
**For it:** [supporting argument]
**Against it:** [counterargument]

## Evolution Summary
| Cycle | Ideas In | Survived | Top Score | Diversity | Strategy | Decision |
|-------|----------|----------|-----------|-----------|----------|----------|

## Meta-Learning Trajectory
- [How strategy evolved across cycles]

## Evolutionary Insights (from The Historian)
- [Dominant lineages, fertile combinations, fitness landscape, problem revelations]

Configuration

{
  "problem": "...",
  "time_scale": "weeks",
  "domains": ["primary", "adjacent-1", "adjacent-2"],
  "scoring_weights": {"feasibility": 1.0, "novelty": 1.0, "impact": 1.0, "elegance": 1.0},
  "convergence_prevention": {
    "cross_phase_breeding_min": 0.2,
    "immigrant_ideas_per_cycle": 3,
    "kill_threshold": 0.5,
    "forced_new_domain_per_cycle": true
  },
  "loop_control": {
    "mode": "adaptive",
    "target_score": null,
    "max_stagnation_cycles": 3,
    "max_strategy_pivots": 2,
    "diversity_floor": 0.3
  },
  "external_validation": {"enabled": false, "hooks": ["MarketSearch"]},
  "randomness": {"seed": null, "subset_ratio": 0.33, "mutation_operations": 8}
}

Integration with Other Skills

Algorithm Integration

When the PAI Algorithm sets mode: ideate (via PAI/ALGORITHM/ideate-loop.md), it loads this skill and routes to Workflows/FullCycle.md by default. Tunable parameters from the algorithm's parameter-schema.md map to the configuration above. The Meta-Learner may adjust parameters within bounds; user-explicit overrides are auto-locked.

Gotchas

• Ideate is for multi-cycle evolutionary ideation — not quick brainstorming. For fast divergent ideas, use BeCreative.
• The Loop Controller manages cycle count — don't override it manually. Trust the budget-based cycling.
• Meta-learner adjustments happen automatically within parameter bounds. Don't manually tune mid-cycle.
• CONTEMPLATE is mandatory. Skipping it degrades MATE quality because STEAL operates on disconnected material.
• Structural randomness defeats LLM bias. Don't substitute "interesting pairs picked by the LLM" for Fisher-Yates — the bias is the problem.

Citations

• The 9-phase decomposition and the path-to-ASI mapping derive from a publicly published essay on cognitive progress and a possible path to ASI by D. {{PRINCIPAL_SURNAME}} (2024). The framework name Cognitive Progress Workflow refers to that essay.
• The Lamarckian advantage framing (Phase 9 META-LEARN) borrows from research on auto-research loops and meta-learning in agent systems (cf. Karpathy auto-research pattern).
• Structural randomness as a defeat for LLM-bias is empirical — see internal experiments comparing LLM-picked pairings vs Fisher-Yates pairings on diversity metrics.

Execution Log

After completing any workflow, append a single JSONL entry:

echo '{"ts":"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'","skill":"Ideate","workflow":"WORKFLOW_USED","input":"8_WORD_SUMMARY","status":"ok|error","duration_s":SECONDS}' >> ~/.claude/PAI/MEMORY/SKILLS/execution.jsonl

Dream — DREAM Phase Only (Free-Association Recombination)

Use when: you want pure unconstrained recombination of input material with NO awareness of the problem. The connection-to-problem step is left to a downstream consumer (you, or a follow-up Mate/Test workflow).

Phase invoked: DREAM only (noise=0.9). No CONSUME (caller supplies inputs), no scoring, no iteration.

Voice Notification

curl -s -X POST http://localhost:31337/notify \
  -H "Content-Type: application/json" \
  -d '{"message": "Running the Dream workflow in the Ideate skill to free-associate inputs"}' \
  > /dev/null 2>&1 &

Inputs

• Input pool (required): a list of atomic ideas, facts, patterns. 10-30 items recommended.
• Agent count (optional, default 3): how many Dreamer agents run in parallel
• Subset ratio (optional, default 0.33): each agent gets pool_size × ratio random items

Steps

1. Structural randomness: for each Dreamer agent, generate a random subset of floor(pool_size × subset_ratio) items via Fisher-Yates shuffle with a cryptographic seed (NOT LLM-selected). Different agents see different subsets.

2. Spawn `agent_count` Dreamer agents in parallel via Task tool. Each receives:

• Its random subset
• The instruction: "Forget any problem context. Just combine these inputs freely. What connections do you see that nobody has made? What if X was Y? What if you turned Z inside out?"
• Trait composition: creative + visionary + unconventional
• Invoke Skill("BeCreative") MaximumCreativity workflow inside each agent

3. Each agent produces 3-5 dream fragments. Output is markdown with:

• Fragment text (1-3 sentences each)
• Source-input IDs that contributed (provenance)
• No fitness evaluation — dreams are not judged here

Output

## Dream Fragments

### Agent 1 — The Dreamer (subset: ideas 3, 7, 12, 19, 24)

1. [Fragment text]
   Provenance: ideas 7+12

2. [Fragment text]
   Provenance: ideas 3+24

...

### Agent 2 — The Dreamer (subset: ideas 1, 5, 11, 18, 22)

...

Distinguishing Notes

• DREAM has NO awareness of the problem. If you want gentle problem-tethering, use Daydream.md instead (noise=0.5, problem held loosely).
• Structural randomness is the point. Two agents with the same input will produce more similar output than two agents with genuinely different random subsets. The randomness comes from WHICH ideas they see, not from LLM temperature.
• Output is raw material, not solutions. Downstream consumers (Mate, Test, or a human reviewer) judge applicability.

Execution Log

echo '{"ts":"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'","skill":"Ideate","workflow":"Dream","input":"8_WORD_SUMMARY","status":"ok|error","duration_s":SECONDS}' >> ~/.claude/PAI/MEMORY/SKILLS/execution.jsonl

FullCycle — All 9 Phases via Loop Controller

Default Ideate workflow. Runs the full evolutionary cycle through all 9 phases (CONSUME → DREAM → DAYDREAM → CONTEMPLATE → STEAL → MATE → TEST → EVOLVE → META-LEARN), with a Loop Controller that decides continue / pivot / stop after each cycle.

Voice Notification

curl -s -X POST http://localhost:31337/notify \
  -H "Content-Type: application/json" \
  -d '{"message": "Running the FullCycle workflow in the Ideate skill to evolve novel solutions"}' \
  > /dev/null 2>&1 &

Inputs

• Problem statement (required): the question or challenge to ideate against
• time_scale (optional, default weeks): hours | days | weeks | months | years | decades → maps to time budget
• domains (optional): seed list of domains to consume from
• seed_urls / seed_ideas (optional): starting material for cycle 1
• Loop config (optional): see Configuration in ../SKILL.md

Phase Flow

Phases run sequentially within a cycle (each phase consumes the previous phase's output). Agents within a phase run in parallel (Council pattern). Two mid-cycle checkpoints gate progression. The Loop Controller decides cycle-boundary actions.

Phase 1: CONSUME (Ingest)

Input: Problem statement + optional seeds. On cycle 2+, also receives survivors from EVOLVE, research questions from META-LEARN, and domain weight adjustments.

How:

• Invoke Skill("Research") in standard or extensive mode across problem-adjacent and problem-distant domains
• Require minimum 3 distinct domains per cycle (prevents monoculture)
• Domain selection is weighted by Meta-Learner output but includes a random lottery element
• Extract atomic ideas (one concept per item); tag each with source domain, confidence, surprise factor
• Diversity requirement: span at least 3 of: direct domain, adjacent domain, distant domain, historical, contrarian

Agent: The Glutton — voracious, omnivorous. Trait composition: enthusiastic + research + thorough

Phase 2: DREAM (Perturb at noise=0.9)

Input: Raw Input Pool from CONSUME

How:

• Invoke Skill("BeCreative") MaximumCreativity workflow
• Each agent receives a random subset of the Input Pool (default N/3) selected by Fisher-Yates shuffle with cryptographic seed (NOT LLM-selected — structural randomness)
• Instruction: "Forget the problem. Just combine these inputs freely. What connections do you see that nobody has made?"
• 3 agents × 3-5 fragments = 9-15 dream fragments per cycle

Distinguishing feature: DREAM has NO awareness of the problem. Pure free-association on random input subsets.

Agent: The Dreamer — wild, poetic. Trait composition: creative + visionary + unconventional

Phase 3: DAYDREAM (Perturb at noise=0.5)

Input: Raw Input Pool + Dream Fragments + Problem Statement (loosely held)

How:

• Agents receive accumulated material PLUS a gentle reminder of the problem
• Instruction: "The problem exists in the background. You're not trying to solve it. You're wandering. What catches your eye?"
• 2-3 agents × 3-5 tangential insights each

Distinguishing feature: DAYDREAM knows about the problem but isn't trying to solve it. The constraint relaxation IS the mechanism.

Agent: The Wanderer — curious, easily distracted. Trait composition: curious + exploratory + playful

Phase 4: CONTEMPLATE (Perturb at noise=0.1) — MANDATORY

ENFORCEMENT: Skipping CONTEMPLATE is a hard error. Without it, STEAL and MATE operate on disconnected material.

Input: Everything accumulated so far (Input Pool + Dream Fragments + Tangential Insights + Problem Statement front-and-center)

How:

• Invoke Skill("IterativeDepth") with 4 lenses: Literal, Failure, Analogical, Constraint Inversion
• Instruction: "Given everything you've seen — now think seriously. What patterns emerge? What would a structured approach look like?"
• 2-4 agents × 2-4 structured analyses each

Mid-Cycle Checkpoint A:

• Gate: "Do at least 30% of structured analyses reference the original problem statement?"
• If FAIL: re-run CONTEMPLATE with problem statement injected more prominently

Agent: The Sage — deep, methodical. Trait composition: analytical + systematic + precise

Phase 5: STEAL (Cross-Pollinate)

Input: Problem Statement + Structured Analyses

How:

• Invoke Skill("Research") targeting domains selected via weighted random lottery from the 50+ candidate domain pool
• Each cycle's STEAL must include at least 1 domain NOT used in the previous cycle (forced exploration)
• For each foreign domain, find 2-3 patterns/solutions/approaches that solve analogous problems
• Map each foreign pattern onto the problem: "In [foreign domain], they solve [analogous problem] by [technique]. Applied to our problem: [mapping]."
• 3-5 agents × different foreign domain each

Agent: The Thief — street-smart, no respect for domain boundaries. Trait composition: resourceful + cross-domain + opportunistic

Phase 6: MATE (Genetic Recombination)

Input: ALL accumulated ideas from phases 1-5

How:

• Select idea pairs using Fisher-Yates shuffle (structural randomness, not LLM-selected)
• Pre-allocated cross-phase slots: first 20% of pairs are forced cross-phase (e.g. Dream Fragment + Borrowed Pattern)
• For each pair, perform THREE operations:
• Crossover: element A from idea 1 + element B from idea 2
• Mutation: dice-roll from 8 mutation operations (see Structural Randomness Engine in ../SKILL.md)
• Cloning with drift: copy one parent with small random modifications
• Each agent produces 3-5 offspring; minimum 10 offspring per cycle (prevents premature convergence)
• Explicitly instruct agents to produce BAD ideas too — selection happens in TEST

Agent: The Matchmaker — sees compatibility where others don't. Trait composition: creative + combinatorial + bold

Phase 7: TEST (Select)

Input: All Offspring Ideas from MATE + Problem Statement (as fitness function)

Scoring dimensions (each 0-100): Feasibility, Novelty, Impact, Elegance

How:

• Invoke Skill("RedTeam") to adversarially attack each candidate
• 3-5 judge agents independently score each candidate on all 4 dimensions
• Final score = average across judges; confidence = inverse of variance
• Each judge provides: score, 1-sentence supporting argument, 1-sentence counterargument
• External validation (optional): pluggable hooks add real-world signal as score modifiers

Mid-Cycle Checkpoint B:

• Gate: "Is this cycle's avg composite score >= previous cycle's avg − 5 points?"
• If FAIL: increment stagnation_counter in Loop Controller. If counter ≥ 2, Meta-Learner is triggered to propose strategy pivot before EVOLVE.

Agent: The Judge — harsh, fair. Trait composition: critical + analytical + skeptical

Phase 8: EVOLVE (Iterate)

Input: Scored Candidates from TEST

How:

• Selection: Rank by composite score (adjusted for external validation if enabled)
• Kill threshold: Bottom 50% eliminated (no carry-forward)
• Elitism: Top 10% carry forward UNCHANGED
• Mutation: Remaining 40% carry forward with dice-roll mutations from 8 defined operations
• Diversity injection: Add 2-3 completely new random ideas (immigrants) to prevent gene pool collapse
• Output report: ideas in, ideas out, average fitness, diversity index, top 3 candidates
• Feed forward: Survivors + full scoring data passed to META-LEARN

Agent: The Curator — cold, efficient. Trait composition: strategic + decisive + unsentimental

Phase 9: META-LEARN (Lamarckian Learning)

Input: Full cycle results — survivors, killed ideas, scoring data, provenance chains, phase contribution stats

How:

1. Fitness landscape analysis: which parent domains produced highest-scoring offspring? which phases contributed most to survivors? what scoring dimensions are hardest to satisfy?

2. Strategy adjustments (JSON output):

   {
     "domain_weights": {"biology": 1.5, "history": 0.5},
     "phase_weights": {"DREAM": 0.7, "STEAL": 1.3},
     "noise_adjustment": -0.1,
     "new_domains_to_explore": ["game-theory", "logistics"],
     "kill_threshold_adjustment": 0.05,
     "breeding_strategy": "favor cross-domain over within-domain"
   }

3. Question generation: synthesizes 3-5 specific research questions based on what this cycle revealed; these seed the next cycle's CONSUME phase

Agent: The Scientist — meta-analytical. Trait composition: meta-analytical + strategic + adaptive

Loop Controller Decision

After META-LEARN completes, the Loop Controller evaluates:

IF budget_seconds_remaining <= 0:
    STOP (budget exhausted)
ELIF stagnation_counter >= 3:
    IF strategy_pivots_remaining > 0:
        PIVOT (shift domains, noise levels, agent composition)
    ELSE:
        STOP (exhausted all strategies)
ELIF fitness_history[-1].diversity_index < 0.3:
    PIVOT (diversity collapse — inject immigrants and widen search)
ELIF fitness_history[-1].top_score >= target_score (if set):
    STOP (target reached)
ELSE:
    CONTINUE

On STOP, invoke the Insight Extractor (The Historian) for post-loop analysis.

Post-Loop: Insight Extractor

Runs once after the Loop Controller issues STOP. Analyzes the entire evolutionary run.

Output sections:

• Dominant Lineages (which idea families dominated, common ancestors of top scorers)
• Fertile Combinations (which domain pairings produced breakthrough offspring)
• Fitness Landscape (peaks, valleys, unexplored regions)
• Problem Understanding (what the process revealed about the problem itself)
• Recommendations for Further Exploration

Agent: The Historian — retrospective, sees the forest. Trait composition: archival + synthesizing + retrospective

State Persistence

Each run persists to ~/.claude/PAI/MEMORY/WORK/{slug}/ideate/. See ../SKILL.md § "State Persistence" for the full directory layout and idea data structure.

Final Output

See ../SKILL.md § "Final Output Format" for the markdown template.

Execution Log

echo '{"ts":"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'","skill":"Ideate","workflow":"FullCycle","input":"8_WORD_SUMMARY","status":"ok|error","duration_s":SECONDS}' >> ~/.claude/PAI/MEMORY/SKILLS/execution.jsonl

Mate — MATE Phase Only (Genetic Recombination)

Use when: you have a pool of existing ideas and want to breed novel offspring via crossover + mutation. No new research, no scoring — pure recombination.

Phase invoked: MATE only.

Voice Notification

curl -s -X POST http://localhost:31337/notify \
  -H "Content-Type: application/json" \
  -d '{"message": "Running the Mate workflow in the Ideate skill to recombine ideas into offspring"}' \
  > /dev/null 2>&1 &

Inputs

• Idea pool (required): list of existing ideas to breed (typically 8-30 items)
• Phase tags (optional): mark each input idea with its origin phase (e.g. "Dream", "Steal", "Contemplate") to enable cross-phase pairing enforcement
• Offspring count (optional, default 10): minimum number of offspring to produce
• Cross-phase ratio (optional, default 0.2): proportion of pairings forced cross-phase

Steps

1. Pair selection via Fisher-Yates shuffle:

• Bucket inputs by phase tag (if provided)
• Pre-allocate cross_phase_ratio × offspring_count slots — these are forced cross-phase pairs (one input from each of two different phase buckets, randomized within bucket)
• Remaining slots: shuffle the full pool, pair adjacent items
• Critical: do NOT ask the LLM to pick "interesting pairs" — structural randomness defeats LLM bias toward training-distribution-favored pairings

2. Spawn Matchmaker agents in parallel via Task tool. Each receives a subset of the pairs. For each pair, the agent performs THREE operations:

• Crossover: "Take element A from idea 1, element B from idea 2. Combine into a new idea."
• Mutation: Roll an 8-sided die. Apply the corresponding mutation operation:

1. Flip one assumption 2. Invert the constraint 3. Change the scale (10× bigger or smaller) 4. Change the time horizon 5. Merge with a random element from another idea in the pool 6. Apply a constraint from a random domain 7. Remove the most complex component 8. Add an adversarial requirement

• Cloning with drift: "Copy one parent idea with small random modifications."

Trait composition: creative + combinatorial + bold

3. Explicitly instruct agents to produce BAD ideas too — selection is not happening here, so don't pre-filter. Diversity matters more than quality at this phase.

4. Aggregate offspring with full provenance:

• Parent IDs
• Operation type (crossover / mutation / clone)
• Mutation die-roll (if mutation was applied)
• Phase-bucket origins of parents

Output

[
  {
    "id": "offspring-001",
    "text": "Apply mycelial chemical-gradient signaling to API rate limiting",
    "provenance": {
      "parents": ["idea-007", "idea-019"],
      "operation": "crossover",
      "mutation_die_roll": null,
      "parent_phases": ["Steal", "Contemplate"],
      "is_cross_phase": true
    }
  },
  {
    "id": "offspring-002",
    "text": "...",
    "provenance": { "parents": ["idea-003"], "operation": "clone-with-drift", ... }
  }
]

Distinguishing Notes

• Pairing randomness defeats LLM bias. "Interesting pairs" picked by an LLM converge on training-distribution patterns. Random pairs surface the surprises.
• Cross-phase enforcement is the convergence brake. Without it, the gene pool narrows to one phase's flavor. The 20% floor is empirical.
• Bad offspring are wanted here. Selection is downstream. Filtering at MATE collapses diversity.

Execution Log

echo '{"ts":"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'","skill":"Ideate","workflow":"Mate","input":"8_WORD_SUMMARY","status":"ok|error","duration_s":SECONDS}' >> ~/.claude/PAI/MEMORY/SKILLS/execution.jsonl

QuickCycle — Compressed 4-Phase Single Cycle

Use when: you want fast novelty without the full Loop Controller machinery. Single cycle, no META-LEARN, no strategy pivots, no Lamarckian feedback. Trades depth for speed.

Phase set: CONSUME → STEAL → MATE → TEST. Skips DREAM, DAYDREAM, CONTEMPLATE (the perturbation phases) and EVOLVE/META-LEARN (the iteration phases). Output is a single batch of scored candidates.

Voice Notification

curl -s -X POST http://localhost:31337/notify \
  -H "Content-Type: application/json" \
  -d '{"message": "Running the QuickCycle workflow in the Ideate skill to fast-generate novel candidates"}' \
  > /dev/null 2>&1 &

Inputs

• Problem statement (required)
• domains (optional, defaults to 2-3 domains chosen heuristically from the problem)
• target_count (optional, default 8): how many scored candidates to return

Steps

1. CONSUME

• Invoke Skill("Research") in standard mode (NOT extensive — speed matters)
• Pull from 2-3 domains (default for QuickCycle): direct domain + 1-2 distant domains
• Extract atomic ideas, tag with source domain
• Output: 10-20 raw input items

2. STEAL

• Invoke Skill("Research") targeting 2 foreign domains via random lottery from the standard 50+ domain pool
• For each foreign domain, find 2-3 patterns/solutions
• Map each foreign pattern onto the problem
• Output: 4-6 borrowed pattern mappings

3. MATE

• Combine CONSUME output + STEAL output into one pool
• Fisher-Yates shuffle the pool, pair adjacent items (no cross-phase enforcement at this scale — pool is already mixed)
• For each pair: crossover + dice-roll mutation (8 mutation operations from ../SKILL.md § Structural Randomness Engine)
• Skip the cloning-with-drift step (only crossover + mutation in QuickCycle for speed)
• Output: target_count × 1.5 offspring (15-20% will be killed in TEST)

4. TEST

• 3 judge agents independently score each offspring on 4 dimensions: Feasibility, Novelty, Impact, Elegance
• Final score = average; confidence = inverse of variance
• Each judge: score + 1-sentence supporting argument + 1-sentence counterargument
• Skip RedTeam adversarial pass (FullCycle has it; QuickCycle trades depth for speed)
• Skip external validation hooks
• Drop bottom 25%; return top target_count ranked by composite score

Output

Markdown report with:

• Top N candidates ranked by composite score
• Each candidate: scores per dimension, supporting/counter argument, provenance (parent IDs + operation type)
• One-line summary of input pool composition

No Insight Extractor (single cycle has no cross-cycle pattern to extract). No Loop Controller state file.

When NOT to use this

• Need genuinely novel ideas (no DREAM/DAYDREAM = bounded creativity) → use FullCycle
• Need adaptive strategy (no META-LEARN = no learning across cycles) → use FullCycle
• Just need divergent ideas without scoring → use Skill("BeCreative") instead

Execution Log

echo '{"ts":"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'","skill":"Ideate","workflow":"QuickCycle","input":"8_WORD_SUMMARY","status":"ok|error","duration_s":SECONDS}' >> ~/.claude/PAI/MEMORY/SKILLS/execution.jsonl

Steal — STEAL Phase Only (Cross-Domain Pattern Transfer)

Use when: you want to scavenge solutions from foreign domains and map them onto your problem. Pure cross-pollination — no scoring, no breeding, no iteration.

Phase invoked: STEAL only.

Voice Notification

curl -s -X POST http://localhost:31337/notify \
  -H "Content-Type: application/json" \
  -d '{"message": "Running the Steal workflow in the Ideate skill to map foreign-domain patterns onto the problem"}' \
  > /dev/null 2>&1 &

Inputs

• Problem statement (required): defines what to look for in foreign domains
• Domains (optional): explicit list of domains to scavenge from. If omitted, drawn via weighted random lottery from the standard 50+ candidate pool.
• Patterns per domain (optional, default 3): how many patterns each agent extracts from its assigned domain
• Agent count (optional, default 3-5): one agent per domain

Steps

1. Domain selection:

• If user supplied domains: use those
• Otherwise: weighted random lottery from the 50+ candidate pool (defined in ../SKILL.md § Structural Randomness Engine)
• Force constraint: at least 1 domain must be DISTANT from the problem's native field (biology for software, jazz for military, etc.)

2. Spawn one Thief agent per domain in parallel via Task tool. Each receives:

• Problem statement
• Its assigned foreign domain
• Trait composition: resourceful + cross-domain + opportunistic
• Instruction: "In your assigned domain, find 2-3 patterns/solutions/approaches that solve problems analogous to ours. For each, write the mapping: 'In [foreign domain], they solve [analogous problem] by [technique]. Applied to our problem: [mapping].'"
• Each agent invokes Skill("Research") to gather domain-specific material

3. Aggregate the borrowed patterns into a single output. Each pattern includes:

• Foreign domain name
• The analogous problem in the foreign domain
• The technique that solves it
• The mapped application to our problem
• Strength of analogy (1-5, agent's self-assessment)

Output

## Borrowed Patterns

### From Mycology (Agent: The Thief)

1. **Mycelial network consensus** (analogy strength: 5)
   - Foreign problem: distributed nutrient allocation across forest floor
   - Foreign technique: chemical gradient signaling, no central coordinator
   - Mapped: distributed system consensus via gossip protocol with bias-vector signals

2. **Sclerotia dormancy** (analogy strength: 3)
   - ...

### From Jazz Performance (Agent: The Thief)

1. **Trading fours** (analogy strength: 4)
   - ...

Distinguishing Notes

• Domain selection is structurally random. Don't ask the LLM to "pick interesting domains" — the lottery defeats LLM bias toward training-distribution-favored domains.
• The mapping IS the creative act. The pattern exists in the foreign domain; the cross-domain application is novel. If a pattern can't be mapped, it's not borrowed — it's noise.
• No scoring here. Steal produces raw cross-pollination material. Use Test (or FullCycle) to score these against fitness criteria.

Execution Log

echo '{"ts":"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'","skill":"Ideate","workflow":"Steal","input":"8_WORD_SUMMARY","status":"ok|error","duration_s":SECONDS}' >> ~/.claude/PAI/MEMORY/SKILLS/execution.jsonl

Test — TEST Phase Only (Multi-Judge Fitness Evaluation)

Use when: you have a pool of candidate ideas and want them scored on the standard 4 dimensions (Feasibility, Novelty, Impact, Elegance). No breeding, no selection, no iteration — just scoring.

Phase invoked: TEST only. Optionally invokes RedTeam for adversarial pass.

Voice Notification

curl -s -X POST http://localhost:31337/notify \
  -H "Content-Type: application/json" \
  -d '{"message": "Running the Test workflow in the Ideate skill to score candidate ideas"}' \
  > /dev/null 2>&1 &

Inputs

• Candidates (required): list of idea texts to score
• Problem statement (required): defines the fitness function
• Judge count (optional, default 3): number of judge agents per candidate
• RedTeam pass (optional, default true): adversarial attack on candidates before scoring
• External validation hooks (optional): see ../SKILL.md § External Validation Hooks

Steps

1. Optional adversarial pass: if redteam_pass is true, invoke Skill("RedTeam") to attack each candidate. Surfaced fatal flaws are appended to the candidate metadata before scoring (judges see them).

2. Spawn `judge_count` Judge agents in parallel via Task tool. Each judge independently scores ALL candidates. Trait composition: critical + analytical + skeptical.

3. Each judge scores each candidate on 4 dimensions (0-100 each):

For each dimension, the judge provides:

• Score (0-100)
• 1-sentence supporting argument
• 1-sentence counterargument

4. Aggregate across judges:

• Final score per dimension = average across judges
• Composite score = average of 4 dimension scores
• Confidence = inverse of judge variance (high variance = low confidence)

5. External validation (optional): if any hooks are enabled, run them on each candidate. Hook returns { modifier: -20..+20, evidence: string }. Adjusted composite = base composite + sum of modifiers (capped to ±20).

Output

[
  {
    "id": "candidate-001",
    "text": "Apply mycelial chemical-gradient signaling to API rate limiting",
    "scores": {
      "feasibility": 68,
      "novelty": 84,
      "impact": 72,
      "elegance": 79,
      "composite": 75.75,
      "confidence": 0.81,
      "judge_variance": 9.2
    },
    "arguments": {
      "supporting": "Mycelial networks solve consensus without coordinator using gradients — directly analogous to gossip protocols",
      "counter": "Chemical gradient propagation is O(n) — may not scale beyond biological distances"
    },
    "redteam_findings": ["Latency spikes under partition", "No clear primary for write path"],
    "external_validation": {
      "market_search": { "modifier": -5, "evidence": "Partial prior art in gossip protocols" }
    },
    "adjusted_composite": 70.75
  }
]

Distinguishing Notes

• Multi-judge defeats single-judge bias. One judge's ceiling becomes the system's ceiling. Three or more judges with averaging neutralizes this.
• Variance IS information. High inter-judge variance means the idea is polarizing — judges legitimately disagree. Low variance means consensus. Both are signal.
• Skip external validation for fast iteration. Hooks add real-world signal but cost latency. For brainstorming, internal scoring alone is fine.

Execution Log

echo '{"ts":"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'","skill":"Ideate","workflow":"Test","input":"8_WORD_SUMMARY","status":"ok|error","duration_s":SECONDS}' >> ~/.claude/PAI/MEMORY/SKILLS/execution.jsonl