# How the Agentic-Council Plugin Facilitates Multi-Agent Deliberation in Claude Code

> Discover how the agentic-council plugin streamlines multi-agent deliberation in Claude Code. Orchestrate specialized agents for balanced insights from diverse expert perspectives.

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

---

**The agentic-council plugin implements a lightweight orchestration layer that enables Claude Code to coordinate specialized agents through a structured, turn-based deliberation protocol, synthesizing balanced insights from diverse expert perspectives.**

The `agentic-council` plugin, registered in the `anthropics/claude-plugins-community` repository, provides a council-based architecture that moves beyond single-agent responses. By implementing a deterministic **multi-agent deliberation** system, this plugin allows users to spin up a "council" of specialized roles—such as **Security Analyst**, **DevOps Engineer**, and **Product Manager**—that engage in a structured debate before producing a synthesized answer.

## Core Architecture Components

The plugin's architecture relies on three primary components that work together to manage the deliberation lifecycle: an orchestrator skill, specialized agent templates, and a state management system.

### Council Orchestrator Skill

At the heart of the system is the **council orchestrator skill**, exposed through the `/council` command. According to the plugin registry in [`/.claude-plugin/marketplace.json`](https://github.com/anthropics/claude-plugins-community/blob/main//.claude-plugin/marketplace.json) (lines 704-711), this orchestrator receives the user prompt and manages the entire deliberation flow. It initializes child agents, enforces the turn-based protocol, and coordinates the final synthesis step.

The orchestrator operates as the central controller, ensuring that each specialized agent contributes to the conversation according to a fixed sequence before any aggregation occurs.

### Agent Templates and Specialization

Each council member operates from a distinct **agent template** stored in the external repository at `https://github.com/dtsong/agentic-council`. These templates define role-specific system prompts that enforce isolation and specialization—for example, constraining one agent to focus solely on security implications while another evaluates performance characteristics.

When a user invokes the council, the orchestrator dynamically loads these templates and injects the user's query into each one. This ensures every agent processes the same core question through the lens of their specialized expertise.

### Turn-Based Exchange Protocol

The deliberation follows a strict **three-phase protocol** (proposal → critique → synthesis) implemented in the external repository's `council/` source folder. During the turn-based exchange, each agent generates a response in sequence, optionally rebuts prior replies, and contributes to a running transcript. The orchestrator enforces deterministic turn order, preventing any single agent from dominating the discussion while guaranteeing all voices are heard.

### State Persistence Mechanism

Intermediate deliberation states—including agent responses, rebuttals, and the complete transcript—are maintained in a temporary JSON object attached to the skill call. This state persistence, implemented within the orchestrator logic, allows users to resume deliberations using session identifiers or debug the council's reasoning process by inspecting the full turn-by-turn history.

## How Multi-Agent Deliberation Works

The **agentic-council plugin** facilitates effective deliberation through four key mechanisms that mirror real-world committee dynamics.

**Isolation Plus Specialization**
Each child agent executes with its own isolated system prompt, ensuring focused expertise without cross-contamination of perspectives. This architectural isolation guarantees that a security specialist evaluates threats independently from a usability expert's concerns.

**Deterministic Turn Order**
The orchestrator enforces a strict round-robin schedule through the three-phase protocol. This deterministic sequence ensures equitable participation and prevents the "loudest voice" problem common in unstructured multi-agent systems.

**Explicit Synthesis Phase**
Rather than averaging raw outputs, the plugin feeds the complete dialogue transcript into a dedicated **synthesizer agent**—often the orchestrator itself. This agent produces a concise final answer that explicitly captures trade-offs and conflicting viewpoints discussed during the deliberation.

**Extensible Role Configuration**
Adding new perspectives requires only dropping a new template file into the external repository's `council/` directory. The orchestrator automatically discovers and loads these roles at runtime, making the system highly adaptable to domain-specific needs.

## Using the Agentic-Council Plugin

Users interact with the deliberation system through the `/council` skill command, with several flags available to customize the behavior.

### Basic Council Queries

Invoke a standard deliberation by passing your question directly to the council command:

```text
/council What are the biggest security risks when deploying a new web service?

```

This command triggers the orchestrator to instantiate default agents (typically including Security Analyst, DevOps Engineer, and Product Manager roles), execute the three-phase deliberation, and return the synthesized consensus.

### Selecting Custom Agent Roles

Use the `--roles` flag to specify which subset of available agents should participate in the deliberation:

```text
/council --roles security,performance,usability
Explain the trade-offs in choosing a server-less architecture for a real-time gaming backend.

```

The orchestrator loads only the templates matching the specified roles, creating a focused council tailored to the specific evaluation criteria.

### Debugging and Inspecting Transcripts

To examine the internal deliberation process and see each agent's individual contribution, enable debug mode:

```text
/council --debug true
How should we prioritize feature development for our fintech app?

```

When `--debug` is set to `true`, the response includes the complete turn-by-turn transcript, revealing how each specialist argued their position and responded to critiques.

### Session Persistence and Continuation

For complex deliberations that require multiple rounds or follow-up questions, use the `--session-id` flag to maintain continuity:

```text
/council --session-id 12345
Given the previous discussion, what is the recommended next step?

```

The orchestrator retrieves the stored JSON state from the previous council run (associated with ID `12345`), allowing the deliberation to resume with full context of prior arguments and conclusions.

## Technical Implementation Details

The plugin's implementation spans both the community registry and an external source repository.

**Plugin Registry Entry**
The [`/.claude-plugin/marketplace.json`](https://github.com/anthropics/claude-plugins-community/blob/main//.claude-plugin/marketplace.json) file (lines 704-711) contains the canonical definition of the agentic-council plugin, including its metadata, source URL pointing to `https://github.com/dtsong/agentic-council`, and the skill activation command.

**External Repository Structure**
The deliberation logic resides in the external repository's `council/` directory, which contains the orchestrator implementation, individual agent prompt templates, and the synthesis algorithms. The repository's [`README.md`](https://github.com/anthropics/claude-plugins-community/blob/main/README.md) documents the three-phase protocol and provides guidance for creating custom agent roles.

**State Management**
As implemented in the external source code, the orchestrator maintains deliberation state in a structured JSON object that tracks each phase transition, agent responses, and rebuttal chains. This state object attaches to the active skill call, enabling the session persistence features.

## Summary

- The **agentic-council plugin** provides a structured orchestration layer for Claude Code that coordinates multiple specialized agents through a deterministic, turn-based deliberation protocol.
- The system uses **isolated agent templates** stored in the external repository to ensure each council member maintains focused expertise without perspective contamination.
- A **three-phase protocol** (proposal → critique → synthesis) guarantees all voices are heard before the synthesizer agent generates the final balanced answer.
- Users control deliberations through the `/council` command with flags for **custom roles** (`--roles`), **debugging** (`--debug`), and **session persistence** (`--session-id`).
- State persistence in temporary JSON objects allows the orchestrator to resume deliberations or provide transparency into the reasoning process.

## Frequently Asked Questions

### How does the agentic-council plugin prevent one agent from dominating the conversation?

The orchestrator enforces a strict round-robin turn order through the three-phase protocol (proposal → critique → synthesis), ensuring each agent receives exactly one speaking opportunity per phase before any rebuttals or synthesis occurs. This deterministic scheduling prevents dominant agents from monopolizing the deliberation while guaranteeing minority perspectives are captured in the final transcript.

### Can I add custom agent roles to the agentic-council plugin?

Yes, the plugin supports extensible role configuration through the external repository at `github.com/dtsong/agentic-council`. Adding a new perspective requires creating a new prompt template file in the `council/` directory; the orchestrator automatically discovers and loads these templates at runtime. You can then invoke custom roles using the `--roles` flag followed by the template identifiers.

### What is the difference between the raw agent outputs and the final synthesized answer?

The raw transcript contains each agent's individual perspective and rebuttals as generated during the turn-based exchange. The **synthesizer agent**—typically the orchestrator itself—processes this complete dialogue history to produce a final answer that explicitly addresses trade-offs between conflicting viewpoints, rather than merely averaging or concatenating the individual responses. This synthesis step ensures the output reflects the deliberative nuance of the full council discussion.

### Where is the deliberation state stored when using the --session-id flag?

The council's intermediate state, including agent responses, rebuttals, and phase transitions, is maintained in a temporary JSON object attached to the skill call context. According to the implementation in the external repository, this JSON persistence allows the orchestrator to serialize the deliberation state and resume it later when the same `--session-id` is provided, enabling multi-turn deliberations and post-hoc debugging of the reasoning chain.