How Claude Plugins Enable Multi-Agent Workflows: Orchestration, Communication, and Shared State

Claude plugins facilitate multi-agent workflows by bundling orchestrator skills, role-specific sub-skills, and shared tooling into self-contained packages that coordinate autonomous sub-agents through explicit handoffs, messaging tools, and persistent state storage.

In the anthropics/claude-plugins-community repository, multi-agent plugins transform a single Claude instance into a coordinated crew of specialized agents. Each plugin exposes skills (slash commands) and optional MCP tools that together implement patterns like plan → execute → verify. This architecture lets developers compose complex workflows where multiple agents collaborate on codebases, research tasks, or creative projects without losing context between sessions.

Core Architecture of Multi-Agent Plugins

The claude-plugins-community repository defines multi-agent workflows through four interconnected components. Understanding each layer helps developers build their own coordinated agent teams.

Marketplace Index and Plugin Discovery

The .claude-plugin/marketplace.json file serves as the central registry for all community plugins. It lists multi-agent orchestrators alongside single-purpose tools, enabling discovery of pre-built agent teams.

The 10x-team entry demonstrates this pattern explicitly. It declares an orchestrator skill (/10x-team) that runs twelve role-specific sub-skills in sequence—CTO, Architect, Frontend, Backend, DevOps, Security, and others—each with defined gates and hand-off points:

// From marketplace.json L34-L41
{
  "id": "10x-team",
  "name": "10x Team",
  "skills": [
    {"command": "/10x-team", "description": "Orchestrate a full product team"},
    // ... twelve role skills follow
  ],
  "source": "https://github.com/anthropics/claude-plugins-community/tree/main/10x-team"
}

Plugin Manifest and Configuration

Each plugin folder contains a plugin.json that declares metadata, version, and any user-configurable secrets. While single-agent plugins like tres-finance expose API keys for external services, multi-agent orchestrators typically reference sub-plugins through source entries rather than secrets:

// From tres-finance-plugin/.claude-plugin/plugin.json L19-L26
{
  "name": "tres-finance",
  "description": "DeFi portfolio analytics",
  "secrets": [
    {"key": "DEBANK_API_KEY", "description": "DeBank API access token"}
  ]
}

Skill Definitions and Workflow Steps

Skill markdown files (SKILL.md) inside each plugin define the conversational interface and concrete workflow steps. The 10x-team orchestrator explicitly lists which role skills it invokes, establishing a contract for multi-agent execution.

Orchestrator Patterns for Multi-Agent Coordination

Multi-agent plugins in this repository implement two primary coordination patterns: sequential orchestration with state persistence, and message-passing between concurrent agents.

Sequential Orchestration with State Persistence

The 10x-team plugin exemplifies the plan → execute → verify loop. Its orchestrator calls role skills in order, persisting decisions to a hidden project folder (.10x/) so subsequent agents can read previous choices:

# Pseudo-code illustrating 10x-team orchestrator pattern

import os, json, subprocess

STATE_DIR = ".10x"
os.makedirs(STATE_DIR, exist_ok=True)

# 1️⃣ Run CTO role: establish technical vision

result = subprocess.run(["claude", "skill", "cto"], capture_output=True, text=True)
with open(f"{STATE_DIR}/cto.json", "w") as f:
    json.dump(result.stdout, f)

# 2️⃣ Run Architect role, consuming CTO decisions

with open(f"{STATE_DIR}/cto.json") as f:
    cto_data = json.load(f)
result = subprocess.run(
    ["claude", "skill", "architect", "--input", json.dumps(cto_data)],
    capture_output=True, text=True
)
with open(f"{STATE_DIR}/architect.json", "w") as f:
    json.dump(result.stdout, f)

# …additional roles: Frontend, Backend, DevOps, Security…

# Final verification: validate complete artifact

subprocess.run(["claude", "skill", "verify", "--state-dir", STATE_DIR])

This pattern appears in several plugins, including agent-handoff, which implements a hard-coded three-stage handoff between specialized agents.

Inter-Agent Communication via MCP Tools

The agent-comm plugin provides runtime tools that enable agents to message each other without blocking the main session. This supports parallel workstreams and iterative discussions:

# Agent A publishes status update

claude tool call agent-comm.send \
  --channel "team" \
  --message "Design completed, ready for review"

# Agent B subscribes to channel with timeout

claude tool call agent-comm.listen \
  --channel "team" \
  --timeout 30

The agent-comm entry in marketplace.json documents this lightweight publish/subscribe channel for agent coordination.

Shared Memory and Cross-Session Persistence

Long-running multi-agent workflows require state that survives individual Claude sessions. Two plugins address this through different persistence mechanisms.

Explicit Handoff Files

Sequential orchestrators like 10x-team and agent-handoff write JSON handoff files to the project directory. Each role skill reads its predecessor's output and appends its own decisions, creating an auditable chain of custody.

Persistent Knowledge Graphs

The agent-knowledge plugin exposes a SQLite-backed knowledge graph that all sub-agents read and write. This enables "remember-what-we-did-before" behavior across sessions:

# Agent adds structured fact to shared knowledge base

claude tool call agent-knowledge.add \
  --entity "User" \
  --property "hasAccess" \
  --value "true"

# Later agent queries accumulated knowledge

claude tool call agent-knowledge.query \
  --entity "User" \
  --property "hasAccess"

The agent-knowledge entry (L540-L546) in marketplace.json describes this SQLite-based persistence layer.

Composing Custom Multi-Agent Teams

The plugin architecture supports flexibility in team composition through three key mechanisms:

• Mix and match role skills — Combine security-audit skills from agentic-security with 10x-team's core workflow
• Enforce validation gates — Built-in hooks at plan, execute, and verify stages reduce token waste
• Retain state across sessions — Architectural decisions, test artifacts, and knowledge graphs persist in project folders

Implementation Checklist for Multi-Agent Plugins

When building a multi-agent workflow plugin, reference these verified patterns from anthropics/claude-plugins-community:

1. Define orchestrator skill in SKILL.md with explicit role-skill sequence
2. Register in marketplace.json with descriptive id, name, and source URL
3. Create .10x/ or equivalent hidden directory for state persistence
4. Add agent-comm dependency if agents require parallel messaging
5. Include agent-knowledge dependency for cross-session memory requirements

Summary

• Claude plugins enable multi-agent workflows through orchestrator skills that sequence role-specific sub-agents
• State persistence uses hidden project directories (.10x/) and SQLite knowledge graphs (agent-knowledge)
• Inter-agent communication relies on agent-comm MCP tools for publish/subscribe messaging
• The marketplace.json index (L34-L41 for 10x-team, L469-L476 for agent-comm, L530-L537 for agent-handoff, L540-L546 for agent-knowledge) documents all multi-agent primitives
• Developers compose teams by mixing skills from different plugins while enforcing gates at plan/execute/verify stages

Frequently Asked Questions

What is the minimum viable structure for a multi-agent Claude plugin?

A multi-agent plugin requires three files: a SKILL.md defining the orchestrator slash command, a plugin.json with metadata and any secrets, and an entry in marketplace.json linking to the plugin source. The orchestrator skill must implement hand-off logic—either through file-based state passing or agent-comm tool calls—to coordinate sub-agents.

How do sub-agents share context without losing information between Claude sessions?

Plugins use two persistence strategies. Sequential orchestrators like 10x-team write JSON state files to hidden directories (.10x/) that survive session termination. Knowledge-based plugins like agent-knowledge maintain SQLite graphs that agents query and update, enabling structured memory across any number of sessions.

Can agents run in parallel rather than sequentially?

Yes. While 10x-team demonstrates sequential orchestration, plugins incorporating agent-comm enable parallel execution. Agents publish status to named channels and listen for peer updates, allowing non-blocking coordination. The agent-comm entry in marketplace.json documents this pattern with send and listen tool operations.

Where are multi-agent plugin capabilities documented in the repository?

All multi-agent primitives are cataloged in .claude-plugin/marketplace.json. Key entries include 10x-team for full team orchestration (L34-L41), agent-handoff for three-stage workflows (L530-L537), agent-comm for messaging (L469-L476), and agent-knowledge for persistent memory (L540-L546).

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}