# Multi-Agent Collaboration Plugins for Claude Code: Agentic-Council and 10x-Team > Explore how multi-agent collaboration plugins like Agentic-Council and 10x-Team empower Claude Code to automate complex software decisions and implementations through structured specialist agent orchestration. - Repository: [Anthropic/claude-plugins-community](https://github.com/anthropics/claude-plugins-community) - Tags: deep-dive - Published: 2026-09-02 --- **Agentic-Council and 10x-Team transform Claude Code into structured multi-agent systems by orchestrating specialist agents—either through deliberative consensus-building or phased engineering workflows—to automate complex software decisions and implementations.** The `anthropics/claude-plugins-community` repository extends Claude Code beyond single-model interactions through **multi-agent collaboration plugins** that coordinate multiple specialist agents. Both **Agentic-Council** and **10x-Team** (marketplace name for IOx-Team) implement distinct approaches to automated team-based software engineering—one through cyclic deliberation and the other through gated orchestration. ## How Multi-Agent Collaboration Plugins Work Multi-agent collaboration plugins distribute cognitive load across domain-specific **skills**—discrete agent implementations exposed through slash commands. Unlike monolithic AI interactions, these plugins enable complex workflows where specialist agents share state via the file system, mirroring human team dynamics while maintaining automated coordination. According to the marketplace metadata in [`.claude-plugin/marketplace.json`](https://github.com/anthropics/claude-plugins-community/blob/main/.claude-plugin/marketplace.json), both plugins register their orchestration commands and agent definitions within the Claude Code ecosystem, with Agentic-Council defined at lines 704-711 and 10x-Team at lines 34-41. ## Agentic-Council: Deliberative Consensus Building **Agentic-Council** implements a **council-based deliberation model** that convenes approximately 20 specialist agents to resolve complex engineering decisions through structured debate and synthesis. ### Architecture and Three-Round Deliberation Each specialist operates as a separate Claude Code skill (e.g., `/cto`, `/architect`, `/security`). The core `/council` skill orchestrates a **three-round deliberation process**: 1. **Proposal** – Selected agents independently generate recommendations based on the problem context. 2. **Critique** – Agents review and challenge each other's proposals to surface hidden assumptions and risks. 3. **Synthesis** – The council aggregates diverse viewpoints into a unified design document and phased build plan. All agents share a common workspace and read each other's outputs via the standard Claude Code file system, eliminating manual context passing and ensuring every specialist evaluates the full deliberation history. ### Invocation and Usage Activate the council by running: ```markdown /council ``` Claude Code prompts you to select which specialist agents to involve (e.g., `cto`, `security`, `product`), then automatically executes the three-round process and returns a consolidated recommendation with implementation phases. ## 10x-Team (IOx-Team): Full-Stack Engineering Orchestration **10x-Team**, listed in the marketplace as IOx-Team, provides a complete **engineering team simulation** comprising 12 specialized role-based agents plus a central orchestrator that manages end-to-end software development with strict phase gates. ### Architecture and State Persistence Each role is exposed as an individual skill (`/cto`, `/architect`, `/sde`, `/security-engineer`, etc.). The `/10x-team` orchestrator skill drives the entire pipeline, enforcing **hard gates** at every phase transition to prevent premature implementation. State persistence occurs in a hidden project folder (`.10x/`), enabling agents to share decisions and architectural context across conversation boundaries. This file-based shared state reduces token costs by avoiding redundant prompts and maintains continuity between development sessions. ### Phased Development Pipeline The 10x-Team orchestrator implements a **brainstorm-first discipline** with four enforced phases: - **Discovery** – Reverse-engineers existing codebases before proposing changes. - **Design** – Architecture validation with no code generation permitted until approved. - **Implementation** – Structured development with role-specific assignments. - **Verification** – QA and DevOps validation gates. ```markdown /10x-team ``` Executing this command initiates the full pipeline, automatically delegating tasks to the appropriate specialist agent at each stage while maintaining state in `.10x/`. ## Comparing Multi-Agent Approaches While both plugins enable **multi-agent collaboration**, they serve distinct operational needs: - **Agentic-Council** excels at **decision rationalization**, providing diverse expert perspectives on architectural choices through deliberative consensus. Use this when facing complex trade-offs requiring multi-domain input and risk mitigation. - **10x-Team** excels at **execution velocity**, encapsulating complete software development workflows with strict phase gates. Use this for full-stack feature development requiring coordinated product definition, architecture, implementation, and validation. ## Technical Implementation Details The marketplace entries in [`.claude-plugin/marketplace.json`](https://github.com/anthropics/claude-plugins-community/blob/main/.claude-plugin/marketplace.json) define the metadata for both plugins: - **Agentic-Council**: Defined at lines 704-711 with repository URL `https://github.com/dtsong/agentic-council.git`. - **10x-Team**: Defined at lines 34-41 with repository URL `https://github.com/Jaan-Mustafa/10x-Team.git`. Both plugins leverage Claude Code's skill system to expose agent capabilities through intuitive slash commands, with Agentic-Council focusing on dynamic agent selection and 10x-Team emphasizing deterministic phase-based orchestration. ## Summary - **Multi-agent collaboration plugins** transform Claude Code from a single LLM interface into coordinated teams of specialist agents. - **Agentic-Council** uses a three-round deliberation process (proposal → critique → synthesis) with ~20 available specialists to generate vetted design decisions via the `/council` command. - **10x-Team** provides 12 role-specific agents and an orchestrator that enforces hard gates across discovery, design, implementation, and verification phases via the `/10x-team` command. - Both systems share state through the Claude Code file system (workspace for Council, `.10x/` folder for 10x-Team). - Source definitions reside in [`.claude-plugin/marketplace.json`](https://github.com/anthropics/claude-plugins-community/blob/main/.claude-plugin/marketplace.json) at lines 704-711 (Agentic-Council) and lines 34-41 (10x-Team). ## Frequently Asked Questions ### How do I choose between Agentic-Council and 10x-Team? Select **Agentic-Council** when you need deliberative decision-making across multiple domains—such as evaluating architecture trade-offs involving security, performance, and product constraints. Choose **10x-Team** when you require a complete engineering workflow from requirements to deployment, particularly for greenfield development or major refactors requiring disciplined phase gates and role-specific validation. ### Where does multi-agent state persist in these plugins? Agentic-Council agents share context through the standard Claude Code workspace file system, reading each other's outputs from shared directories during the three-round deliberation. 10x-Team persists state in a dedicated `.10x/` directory within your project root, enabling cross-role coordination and conversation continuity without re-prompting previous decisions. ### Can I customize the specialist agents or workflows? Both plugins expose individual agent capabilities through slash commands (e.g., `/cto`, `/architect`), allowing independent invocation of specific roles. You can fork the respective repositories referenced in [`.claude-plugin/marketplace.json`](https://github.com/anthropics/claude-plugins-community/blob/main/.claude-plugin/marketplace.json) to modify agent prompts, add new specialists, or adjust workflow stages such as the deliberation rounds or phase gates. ### What are the performance implications of using multi-agent collaboration? While multi-agent systems consume more tokens than single-prompt interactions, both plugins optimize through **state persistence** and **structured delegation**. 10x-Team specifically reduces redundant prompting by caching decisions in `.10x/`, while Agentic-Council consolidates multiple expert opinions into a single actionable output, reducing the need for iterative manual clarification.