# Clone Army > Clone yourself into identical parallel agents that think independently, divide and conquer any task. Not sub-agents — full copies of YOU. - Skill: `jrennie99-glitch/clone-army` (Agent Skill) - Install (CLI): `npx skillmds add jrennie99-glitch/clone-army` - Raw SKILL.md: https://api.skillmd.com/api/skills/jrennie99-glitch/clone-army/raw - Safety review: pending (external: skill-scanner PASS, skillspector PASS) - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Productivity - Author: jrennie99-glitch (https://skillmd.com/u/jrennie99-glitch) - Updated: 2026-08-19 - Page: https://skillmd.com/skills/jrennie99-glitch/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 ` — Automatically decompose and parallelize any task - `/clone-army deploy ""` — 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 ` — 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: "" mode: "run" label: "clone--" ``` **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: "" ``` ### 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 | Task Complexity | Recommended Clones | Strategy | |---|---|---| | Simple parallel tasks | 2-3 | Divide & Conquer | | Large codebase work | 4-6 | Divide & Conquer | | Critical correctness | 3 | Redundant Verification | | Deep research | 4-5 | Recon Sweep | | Multi-format output | 3-4 | Assembly Line | **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)"