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

> Discover how Claude plugins enable multi-agent workflows by orchestrating communication, managing shared state, and bundling skills for autonomous sub-agents. Learn about explicit handoffs and messaging tools.

- Repository: [Anthropic/claude-plugins-community](https://github.com/anthropics/claude-plugins-community)
- Tags: deep-dive
- Published: 2026-09-06

---

**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`](https://github.com/anthropics/claude-plugins-community/blob/main/.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:

```json
// 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`](https://github.com/anthropics/claude-plugins-community/blob/main/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:

```json
// 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`](https://github.com/anthropics/claude-plugins-community/blob/main/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:

```python

# 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:

```bash

# 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`](https://github.com/anthropics/claude-plugins-community/blob/main/marketplace.json#L469-L476) 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:

```bash

# 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`](https://github.com/anthropics/claude-plugins-community/blob/main/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`](https://github.com/anthropics/claude-plugins-community/blob/main/SKILL.md) with explicit role-skill sequence
2. Register in [`marketplace.json`](https://github.com/anthropics/claude-plugins-community/blob/main/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`](https://github.com/anthropics/claude-plugins-community/blob/main/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`](https://github.com/anthropics/claude-plugins-community/blob/main/SKILL.md) defining the orchestrator slash command, a [`plugin.json`](https://github.com/anthropics/claude-plugins-community/blob/main/plugin.json) with metadata and any secrets, and an entry in [`marketplace.json`](https://github.com/anthropics/claude-plugins-community/blob/main/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`](https://github.com/anthropics/claude-plugins-community/blob/main/marketplace.json#L469-L476) 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`](https://github.com/anthropics/claude-plugins-community/blob/main/.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).