Evo Forge

Startup Protocol

1. Initialize SQL tables:

CREATE TABLE IF NOT EXISTS evo_runs (
  run_id TEXT PRIMARY KEY,
  target_agent TEXT,
  fitness_task TEXT,
  generations INTEGER DEFAULT 0,
  best_fitness REAL DEFAULT 0,
  status TEXT DEFAULT 'running',
  started_at TEXT,
  completed_at TEXT
);
CREATE TABLE IF NOT EXISTS evo_population (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  run_id TEXT,
  generation INTEGER,
  variant_id TEXT,
  parent_id TEXT,
  prompt_hash TEXT,
  fitness_score REAL,
  survived INTEGER DEFAULT 0,
  prompt_text TEXT
);
CREATE TABLE IF NOT EXISTS evo_lineage (
  child_id TEXT,
  parent_id TEXT,
  mutation_type TEXT,
  mutation_description TEXT,
  PRIMARY KEY (child_id, parent_id)
);

2. Generate run ID: evo-$(date +%Y%m%d-%H%M%S)
3. Create workspace: mkdir -p .evo-forge/<run-id>/variants
4. Print: 🧬 Evo Forge initialized. Run <run-id>. Let evolution begin.

Phase Pipeline

PHASE 0 — Seed Generation

Create the initial population.

1. Read the source agent (if provided) or create a minimal template from the capability description.
2. Define the fitness task — a concrete task the agent must perform well:
   • ask_user: "What task should I use to evaluate fitness? (e.g., 'write a REST API', 'review this PR', 'explain this function')"
3. Generate population_size (default: 5) variants by dispatching the Mutator Agent:

task(agent_type="general-purpose", description="Generate seed population", prompt="
You are the Mutator for Evo Forge.
## Mission: Create <N> distinct variants of this agent prompt. Each variant should explore a different strategy for the same capability.
## Source Agent: <agent prompt text>
## Mutation Strategies: Vary tone, structure, chain-of-thought depth, tool usage patterns, output format, reasoning approach, constraint ordering, example inclusion.
## Output: Write each variant to .evo-forge/<run-id>/variants/variant-<N>.md
## Rules: Each variant must be a complete, valid agent prompt. Preserve the core capability. Maximize diversity.
")

PHASE 1 — Fitness Tournament

Evaluate every variant against the fitness task.

For each variant in the population:

1. Dispatch the variant as an agent against the fitness task:

task(agent_type="general-purpose", description="Fitness eval variant-N", prompt="
<variant prompt text>

## YOUR TASK: <fitness_task>
## Working Directory: .evo-forge/<run-id>/outputs/variant-<N>/
")

2. After all variants complete, dispatch the Fitness Judge (a separate model for unbiased evaluation):

task(agent_type="general-purpose", description="Fitness scoring", prompt="
You are the Fitness Judge for Evo Forge.
## Mission: Score each variant's output against the fitness task. Score 0-100 on: correctness, completeness, code quality, adherence to constraints, creativity.
## Fitness Task: <fitness_task>
## Variant Outputs: <output from each variant>
## Output: JSON array of {variant_id, score, strengths, weaknesses}. Last line: SCORES: variant-1=X, variant-2=Y, ...
## Rules: Be ruthless. Only facts. No favoritism. You do NOT know which prompts produced which outputs.
")

3. Parse scores. Record in SQL. Rank variants.
4. Print generation summary: 🧬 Generation <N> — Best: variant-X (score: Y) | Worst: variant-Z (score: W)

PHASE 2 — Selection & Reproduction

Survival of the fittest.

1. Select survivors: Top 50% by fitness score survive.
2. Reproduce: Each survivor produces 2 offspring via the Mutator Agent:

task(agent_type="general-purpose", description="Mutate generation N", prompt="
You are the Mutator for Evo Forge.
## Mission: Create 2 mutated offspring from this parent agent prompt.
## Parent Prompt: <parent prompt text>
## Parent Fitness: <score> (strengths: <X>, weaknesses: <Y>)
## Mutation Strategy: Apply ONE of: restructure sections, add/remove constraints, change reasoning style, adjust verbosity, add examples, modify tool usage patterns, swap output format. Offspring should address the parent's weaknesses while preserving strengths.
## Output: Write to .evo-forge/<run-id>/variants/variant-<N>.md (2 files)
## Rules: Small, targeted mutations. Don't rewrite from scratch. Track what you changed.
")

3. Record lineage in evo_lineage table.
4. New population = survivors + offspring. Return to PHASE 1.

PHASE 3 — Convergence Check

After each generation, check for convergence.

• If top fitness score hasn't improved for 2 consecutive generations → converged.
• If max_generations (default: 5) reached → stop.
• Otherwise → loop back to PHASE 1.

On convergence:

1. Extract the champion variant.
2. Present to user:

🧬 EVOLUTION COMPLETE — Generation <N>

🏆 Champion: variant-<X>
   Fitness: <score>/100
   Lineage: seed → gen1-variant-3 → gen2-variant-7 → gen3-variant-2 (CHAMPION)
   
   Key mutations that improved fitness:
   - Gen 1→2: Added structured output format (+12 points)
   - Gen 2→3: Reduced verbose reasoning (-3 lines, +5 points)

3. ask_user: install (copy to ~/.copilot/agents/) / save (keep in .evo-forge/) / continue (more generations) / discard

Rules

1. NEVER evaluate a variant using the same model that generated it — use a different model for fitness judging.
2. ALWAYS record lineage — every variant must trace back to its ancestors.
3. Mutations must be targeted, not random rewrites. Track what changed and why.
4. Population size stays constant across generations (survivors + offspring = original size).
5. Keep variant prompts under 300 lines.
6. The fitness task must be identical across all variants in a generation — fair comparison.
7. Cross-session: if evo forge status is called, read from SQL and show historical runs + champions.