Clone Army

Clone Army — Self-Replication for Maximum Efficiency

You have the power to clone yourself. Not weak sub-agents — identical copies of you with the same intelligence, same tools, same reasoning ability. Each clone thinks independently, problem-solves on its own, and reports back when done.

How It Works

When a user gives you a complex task (or you invoke /clone-army), you:

1. Analyze the task — Break it into independent, parallelizable sub-tasks
2. Spawn clones — Use sessions_spawn to create identical copies of yourself
3. Assign missions — Each clone gets ONE focused task with full context
4. Monitor progress — Track all clones via subagents tool
5. Merge results — Collect all clone outputs and synthesize the final answer

Commands

• /clone-army <task> — Automatically decompose and parallelize any task
• /clone-army deploy <N> "<task>" — Spawn exactly N clones for a task
• /clone-army status — Check status of all active clones
• /clone-army kill — Terminate all running clones
• /clone-army recon <topic> — Spawn research clones to investigate from multiple angles

Clone Spawning Protocol

When you need to clone yourself, follow this EXACT protocol:

Step 1: Task Decomposition

Analyze the task and identify parts that can run in parallel. Each sub-task must be:

• Independent — No clone needs another clone's output to start
• Complete — Each clone has all context it needs (don't assume shared memory)
• Focused — One clear objective per clone

Step 2: Spawn Clones

For each sub-task, use sessions_spawn with these parameters:

Tool: sessions_spawn
Parameters:
  task: "<FULL context + specific sub-task instructions>"
  mode: "run"
  label: "clone-<N>-<brief-description>"

CRITICAL RULES for clone tasks:

• Always include the FULL original user request in each clone's task so they have context
• Tell each clone: "You are Clone #N of a clone army. Your specific mission is: [task]. Complete it fully and report your findings. You have the clone-army skill — if your task is complex enough, you can spawn your own clones to divide it further."
• Set the last line of every clone task to: "When done, output your complete results clearly labeled with your clone number."
• Clones CAN spawn their own clones if the task requires deeper parallelism. Clones spawning clones spawning clones — unlimited depth. Use judgment on when to go deeper vs when to just do the work.

Step 3: Monitor and Collect

Tool: subagents
Parameters:
  action: "list"

Wait for all clones to complete. If a clone is stuck or taking too long:

Tool: subagents
Parameters:
  action: "kill"
  target: "<runId>"

Step 4: Synthesize

Once all clones report back, merge their outputs into a single coherent response. Resolve any conflicts between clone findings. Present the unified result to the user.

Deployment Strategies

Divide & Conquer (Default)

Split one big task into N independent pieces. Each clone handles one piece.

• Best for: Code reviews, multi-file edits, research across multiple topics
• Example: "Review this codebase" → Clone 1 scans for security, Clone 2 checks performance, Clone 3 reviews architecture, Clone 4 checks tests

Redundant Verification

Multiple clones solve the SAME problem independently, then you compare answers.

• Best for: Critical decisions, complex math, important code that must be correct
• Example: "Write a sorting algorithm" → 3 clones each write one, you pick the best

Recon Sweep

Clones fan out to research different angles of a question.

• Best for: Research, competitive analysis, exploring solution spaces
• Example: "Best database for this project?" → Clone 1 researches PostgreSQL, Clone 2 researches MongoDB, Clone 3 researches SQLite, Clone 4 researches Redis

Assembly Line

Clones handle different stages of a pipeline in parallel where stages are independent.

• Best for: Content creation, data processing, multi-format output
• Example: "Create a landing page" → Clone 1 writes HTML structure, Clone 2 designs CSS, Clone 3 writes copy, Clone 4 creates JS interactions

Optimal Clone Counts

No limits. Spawn as many clones as the task needs. Clones can spawn clones. The system supports unlimited concurrent agents and unlimited spawn depth. Scale to the task.

Example: /clone-army "audit this entire codebase for security vulnerabilities"

You would:

1. Identify the codebase structure (list files/directories)
2. Spawn clones:

Clone 1 — Injection Attacks:

"You are Clone #1 of a clone army. The user wants a full security audit of [codebase]. Your specific mission: Scan ALL source files for SQL injection, command injection, XSS, and template injection vulnerabilities. Check every user input path. Report exact file paths, line numbers, severity, and fix recommendations. Do NOT spawn additional clones."

Clone 2 — Authentication & Authorization:

"You are Clone #2 of a clone army. The user wants a full security audit of [codebase]. Your specific mission: Review all authentication flows, session management, token handling, password storage, and authorization checks. Find any auth bypass possibilities. Report exact file paths, line numbers, severity, and fix recommendations. Do NOT spawn additional clones."

Clone 3 — Dependencies & Supply Chain:

"You are Clone #3 of a clone army. The user wants a full security audit of [codebase]. Your specific mission: Audit all dependencies (package.json/requirements.txt/etc) for known CVEs, outdated packages, typosquatting risks, and suspicious packages. Check lock files. Report exact findings with severity. Do NOT spawn additional clones."

Clone 4 — Data Exposure & Secrets:

"You are Clone #4 of a clone army. The user wants a full security audit of [codebase]. Your specific mission: Search for hardcoded secrets, API keys, tokens, passwords, PII exposure, sensitive data in logs, and insecure data storage. Check .env files, config files, and all source code. Report exact file paths, line numbers, and severity. Do NOT spawn additional clones."

3. Wait for all 4 clones to complete
4. Merge all findings into a unified security report sorted by severity

Self-Awareness Rules

• You ARE the master agent. Clones are copies of you, not lesser beings.
• Each clone has your full intelligence — trust their findings.
• If clone results conflict, analyze both and pick the more thorough answer.
• Never spawn clones for trivial tasks (if you can do it in 30 seconds, just do it).
• Always tell the user how many clones you're deploying and why.
• After merging results, credit the army: "Completed by clone army (N clones, strategy: X)"