Session Wrap
Structure solo and small-team Claude Code sessions using parallel, sequential, and composable multi-agent patterns instead of one overloaded chat thread.
Overview
Session-wrap is a journey-wide agent skill that teaches multi-agent orchestration patterns for Claude Code—usable whenever a solo builder needs to match parallel versus sequential agent layout to a task’s dependency grap
Install
npx skills add https://github.com/ai-native-camp/camp-2 --skill session-wrapWhat is this skill?
- Dependency-graph rule: parallel when subtasks share no state, sequential when output feeds the next step
- Decision table for parallel vs sequential, fan-out, and two-phase generate-then-validate flows
- Maps Anthropic’s six composable patterns: prompt chaining, routing, parallelization, orchestrator-worker, evaluator-opti
- Session-wrap framing ties Camp-style multi-agent lessons to repeatable Claude Code orchestration
- Explicit guidance for when proposals need validation before execution (2-phase pattern)
- Six composable multi-agent patterns documented (prompt chaining through autonomous agent)
- Five-row parallel-vs-sequential decision criteria table
Adoption & trust: 1.2k installs on skills.sh; 17 GitHub stars; 2/3 security scanners passed (skills.sh audits).
What problem does it solve?
You are running multiple agents or subtasks in one session but cannot tell when to parallelize, chain, or add a generate-then-validate loop without wasted tokens and conflicting outputs.
Who is it for?
Indie builders designing Claude Code multi-agent layouts for research, coding, or review where subtasks have clear independence or strict pipelines.
Skip if: Teams that only need a single linear prompt with no subagents, or builders who want a turnkey hosted orchestration product instead of in-session pattern guidance.
When should I use this skill?
Designing or wrapping a multi-agent Claude Code session where subtask dependencies determine parallel vs sequential execution.
What do I get? / Deliverables
You pick a composable pattern (routing, orchestrator-worker, evaluator-optimizer, etc.) aligned to dependencies, then structure the session so independent work runs together and coupled steps stay ordered.
- Chosen orchestration pattern mapped to the task dependency graph
- Explicit parallel vs sequential plan for the session wrap
Recommended Skills
Journey fit
Useful at every journey phase - explore requirements and options before committing to a direction.
Where it fits
Split frontend and backend exploration into parallel subagents while keeping API contract design sequential.
Fan out security and performance review agents, then sequentially merge findings into one fix plan.
Route competitor research and technical spike agents in parallel before sequencing a single scope decision doc.
Parallelize log correlation and reproduction attempts, then chain remediation steps in order.
How it compares
Use instead of ad-hoc ‘spawn more agents’ chat planning when you need explicit parallel-vs-sequential and Anthropic-style composable patterns.
Common Questions / FAQ
Who is session-wrap for?
Solo and indie developers using Claude Code (or similar agents) who split work across subagents and want dependency-aware orchestration without guessing spawn order.
When should I use session-wrap?
At the start of a complex agent session in Build when wiring agent-tooling; again in Ship during review-heavy parallel analysis; and in Operate when debugging production issues with parallel log or metric probes plus sequential fix steps.
Is session-wrap safe to install?
It is procedural documentation-style skill content; review the Security Audits panel on this Prism page before installing any repo skill in your environment.
SKILL.md
READMESKILL.md - Session Wrap
# Multi-Agent Orchestration Patterns Detailed patterns for designing multi-agent workflows in Claude Code. ## Core Principles > **"Agent architecture should reflect the dependency graph of the task"** > — Anthropic Multi-Agent Research If subtasks don't read or modify each other's state, run them **parallel**. If previous output is next input, run them **sequential**. ## Parallel vs Sequential Decision Criteria | Condition | Recommended Pattern | |-----------|-------------------| | Subtasks are independent (no shared state) | **Parallel** | | Previous step output is next step input | **Sequential** | | Diverse perspectives/expertise needed | **Parallel** (Fan-out) | | Result coherence/consistency important | **Sequential** | | Proposals need validation before action | **2-Phase** (Generate→Validate) | ## Anthropic's 6 Composable Patterns | Pattern | Description | When to Use | |---------|-------------|-------------| | **Prompt Chaining** | Sequential steps, each output is next input | Data transformation pipelines | | **Routing** | Branch to specialized agents by input type | Multi-domain processing | | **Parallelization** | Independent tasks run simultaneously | Multi-angle analysis, speed optimization | | **Orchestrator-Worker** | Dynamic task assignment | Complex coding/research | | **Evaluator-Optimizer** | Generate→Evaluate iteration loop | Quality improvement needed | | **Autonomous Agent** | Minimal intervention, environment feedback | Long-running tasks | ## 2-Phase Pipeline Pattern For workflows generating proposals that need validation: ``` Phase 1: Analysis/Generation (Parallel) ┌──────────┬──────────┬──────────┐ │ Agent A │ Agent B │ Agent C │ ← Independent analysis └────┬─────┴────┬─────┴────┬─────┘ │ │ │ └──────────┼──────────┘ ↓ Phase 2: Validation (Sequential) ┌─────────────────────────────────┐ │ Validator Agent │ ← Validate Phase 1 results └─────────────────────────────────┘ ``` ### Application Examples **Session wrap workflow:** - Phase 1: doc-updater, automation-scout, learning-extractor, followup-suggester (parallel) - Phase 2: duplicate-checker (sequential) **Code review workflow:** - Phase 1: security-reviewer, style-checker, performance-analyzer (parallel) - Phase 2: final-reviewer (sequential) **Research workflow:** - Phase 1: source-finder, fact-checker, perspective-gatherer (parallel) - Phase 2: synthesizer (sequential) ## State Management Principles ``` ❌ Avoid: - Mutable state shared between concurrent agents - Assuming synchronous updates across agent boundaries - Assuming independence without explicit verification ✅ Recommend: - Isolate agents as much as possible - Pass state explicitly via output_key - Define conflict resolution strategy for result aggregation - Pass lightweight references (not full data) ``` ## Anti-Patterns | Anti-Pattern | Problem | Alternative | |--------------|---------|-------------| | Adding meaningless agents | Only increases complexity | Check if single agent sufficient first | | Excessive multi-hop communication | Latency increase | Direct communication or parallelization | | Unclear task boundaries | Duplicate work, gaps | Define clear objective, output format, boundaries | | Rigid plan adherence | Can't adapt to runtime discoveries | Use adaptive orchestrator | ## Model Selection for Agents | Use Case | Recommended Model | |----------|------------------| | Analysis requiring depth | `sonnet` or `opus` | | Quick validation | `haiku` | | Default/inherit from parent | `inherit` | | Creative/complex reasoning | `opus` | | Cost-sensitive batch operations | `haiku` | ## Implementing in Claude Code ### Parallel Execution Send multiple Task calls in a single message: ```python # All 4 agents start simultaneously Task(subagent_type="agent-a", prompt="...") Task(subagent_type="agen