Skip to main content
skill CX Codex

agentica-spawn — Claude Code skill: multi-agent patterns

agentica-spawn — a skill that spawns multi-agent patterns via Agentica: swarms for parallel research, hierarchies for role-based tasks, generator-critic loops for iterative refinement, and juries for consensus.

MIT ★ 3,951 updated 2026-01-26

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add parcadei/Continuous-Claude-v3 --skill agentica-spawn -a claude-code
Open on GitHub

What agentica-spawn does

agentica-spawn automates the creation and coordination of agent groups according to the selected pattern. Four built-in modes address different scenarios: Swarm gathers independent perspectives (security, performance, architecture), Hierarchical assigns a coordinator and specialists (planner, implementer, reviewer), GeneratorCritic alternates between generation and critique for up to three rounds, and Jury reaches verdicts by majority vote.

Each spawned agent receives environment variables identifying the swarm run, its role, and the pattern type, allowing it to understand its place in the group. Patterns enable parallelism (Swarm, Jury), distribute tasks by specialty (Hierarchical), or iterate (GeneratorCritic). Pattern selection is either explicit or triggered after agentica-orchestrator.

What it helps with

  • coordinate multiple agents on a single task
  • gather diverse perspectives to strengthen a solution
  • parallelize complex implementation across specialized roles
  • iteratively improve code or decisions through critique loops
  • reach consensus or make final judgment across multiple reviewers

Example prompts for the agent

  • Spawn a Swarm of three experts to analyze API security from multiple angles
  • Create a Hierarchical pattern with coordinator, implementer, and reviewer roles to build a new feature
  • Run GeneratorCritic to refactor code: generator proposes changes, critic flags issues

How to install agentica-spawn

1Skills CLI (Vercel)

npx skills add parcadei/Continuous-Claude-v3 --skill agentica-spawn -a claude-code

2Manually: put the files in place

~/.claude/skills/agentica-spawn/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/agentica-spawn/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about agentica-spawn

How do I install agentica-spawn in Claude Code?

Run npx skills add parcadei/Continuous-Claude-v3 --skill agentica-spawn -a claude-code, then open ~/.claude/skills/agentica-spawn/SKILL.md.

What does agentica-spawn do?

It spawns agent groups according to a selected pattern: Swarm for parallel independent analysis, Hierarchical for role-based task division, GeneratorCritic for iterative refinement, Jury for consensus decisions.

Which patterns are available and when should I use each?

Use Swarm for research (security, performance, architecture reviews), Hierarchical for implementation with clear role separation, GeneratorCritic for iterative improvement, and Jury for validation and consensus.

Source text

SKILL.md · MIT
---
name: agentica-spawn
description: Spawn Agentica multi-agent patterns
user-invocable: false
---

# Agentica Spawn Skill

Use this skill after user selects an Agentica pattern.

## When to Use

- After agentica-orchestrator prompts user for pattern selection
- When user explicitly requests a multi-agent pattern (swarm, hierarchical, etc.)
- When implementing complex tasks that benefit from parallel agent execution
- For research tasks requiring multiple perspectives (use Swarm)
- For implementation tasks requiring coordination (use Hierarchical)
- For iterative refinement (use Generator/Critic)
- For high-stakes validation (use Jury)

## Pattern Selection to Spawn Method

### Swarm (Research/Explore)
```python
swarm = Swarm(
    perspectives=[
        "Security expert analyzing for vulnerabilities",
        "Performance expert optimizing for speed",
        "Architecture expert reviewing design"
    ],
    aggregate_mode=AggregateMode.MERGE,
)
result = await swarm.execute(task_description)
```

### Hierarchical (Build/Implement)
```python
hierarchical = Hierarchical(
    coordinator_premise="You break tasks into subtasks",
    specialist_premises={
        "planner": "You create implementation plans",
        "implementer": "You write code",
        "reviewer": "You review code for issues"
    },
)
result = await hierarchical.execute(task_description)
```

### Generator/Critic (Iterate/Refine)
```python
gc = GeneratorCritic(
    generator_premise="You generate solutions",
    critic_premise="You critique and suggest improvements",
    max_rounds=3,
)
result = await gc.run(task_description)
```

### Jury (Validate/Verify)
```python
jury = Jury(
    num_jurors=5,
    consensus_mode=ConsensusMode.MAJORITY,
    premise="You evaluate the solution"
)
verdict = await jury.decide(bool, question)
```

## Environment Variables

All spawned agents receive:
- `SWARM_ID`: Unique identifier for this swarm run
- `AGENT_ROLE`: Role within the pattern (coordinator, specialist, etc.)
- `PATTERN_TYPE`: Which pattern is running

© parcadei · MIT · parcadei/Continuous-Claude-v3

Similar skills

All skills for Agent setup: memory, context, orchestration →
spawn SuperClaude-Org spawn — a command that breaks down large multi-domain operations into hierarchical task plans with dependencies and delegation. Analyzes scope, decomposes work, and assigns executors—it plans rather than implements. CX Codex +1 ★ 23,950repo stars team-spawn Seth Hobson team-spawn — a slash command for Claude Code, Codex, and Cursor that assembles a multi-agent team from a preset or custom composition. Seven presets cover review, debug, feature work, full-stack, research, security audit, and migration. CX Codex +1 ★ 42,780repo stars hive-mind-advanced ruvnet hive-mind-advanced is a Claude Code skill that coordinates specialized agents through a queen coordinator, consensus, and shared memory. It distributes tasks across complex projects. CX Codex +1 1,100installs swarm-advanced ruvnet swarm-advanced — a skill for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and OpenCode that brings multi-agent swarm patterns to your workflow. Coordinates parallel research, development, and testing across specialized agents. CX Codex +1 1,200installs liaison curiositech liaison turns multi-agent activity into status briefs, decision requests, and progress reports. Use it when project activity is hard to follow. CX Codex +1 181installs Forkit zeintesit Forkit coordinates multiple AI agents within a single project through a shared task queue. Use it when running several agents in parallel and you need them to stay out of each other's way. CX Codex +1 2,269installs

From the same set161

The whole set →
llm-tuning-patterns The llm-tuning-patterns skill recommends LLM settings for theorem proving, code generation, and creative work. Use it to choose token limits and temperature for a specific task. CX Codex +1 ★ 3,951repo stars research-codebase research-codebase — a subagent that automatically documents your codebase. It spawns specialized agents in parallel to locate files, analyze code logic, find usage patterns, and synthesize findings into a single technical report. CX Codex ★ 3,951repo stars search-tools search-tools is a Claude Code skill that routes code searches to LEANN, AST-grep, Morph, or Grep based on the task. CX Codex +1 ★ 3,951repo stars modular-arithmetic Handles modular arithmetic problems in graph number theory. Activates when you need the extended Euclidean algorithm, the Chinese remainder theorem, Euler's theorem, quadratic residues, or order of elements. CX Codex +1 ★ 3,951repo stars parallel-agent-contracts parallel-agent-contracts enforces type ownership rules across parallel agents in TypeScript projects, requiring grep checks and tsc verification before any subtask completes. CX Codex +1 ★ 3,951repo stars spark spark is a Claude Code subagent for small, focused code changes. It handles quick fixes and tweaks, then writes a summary to a project file. CX Codex ★ 3,951repo stars entropy A skill for Shannon entropy, conditional and differential entropy, KL divergence, and maximum entropy principle problems. CX Codex +1 ★ 3,951repo stars proactive-delegation The proactive-delegation rule directs Claude Code to proactively hand off tasks to specialized subagents. It preserves the main context by detecting research, bug fixes, and parallel work automatically. CX Codex +1 ★ 3,951repo stars

Project sponsors

Companies that keep this analytics open