Enum CollaborationPattern 

pub enum CollaborationPattern {
    Pipeline {
        stages: Vec<PipelineStage>,
    },
    MapReduce {
        mapper_role: AgentRole,
        reducer_role: AgentRole,
        chunk_count: usize,
    },
    Debate {
        proponent: AgentRole,
        opponent: AgentRole,
        judge: AgentRole,
        max_rounds: u32,
    },
    Ensemble {
        agents: Vec<AgentRole>,
        aggregation: AggregationStrategy,
    },
    Supervisor {
        supervisor: AgentRole,
        workers: Vec<AgentRole>,
        review_policy: ReviewPolicy,
    },
    Swarm {
        roles: Vec<AgentRole>,
        max_iterations: u32,
        convergence_threshold: f64,
    },
}

A collaboration pattern describing how multiple agents interact to solve a task.

Variants

Pipeline

Sequential processing chain – each stage’s output feeds the next stage’s input, like Unix pipes: Agent A output -> Agent B input -> Agent C input.

Fields

stages: Vec<PipelineStage>

Ordered list of processing stages.

MapReduce

Split work across N mapper agents, then reduce (aggregate) the partial results with a dedicated reducer agent.

Fields

mapper_role: AgentRole

Agent role for the mapping (parallelizable) phase.

reducer_role: AgentRole

Agent role for the reducing (aggregation) phase.

chunk_count: usize

Number of chunks the input is split into.

Debate

Two agents argue opposing positions while a judge evaluates and decides, improving decision quality through adversarial deliberation.

Fields

proponent: AgentRole

Agent role arguing in favor.

opponent: AgentRole

Agent role arguing against.

judge: AgentRole

Agent role making the final decision.

max_rounds: u32

Maximum debate rounds before forcing a decision.

Ensemble

Multiple agents tackle the same task independently and results are aggregated via a configurable strategy (voting, best-of-N, concatenation, LLM synthesis).

Fields

agents: Vec<AgentRole>

Agent roles participating in the ensemble.

aggregation: AggregationStrategy

How the individual results are combined.

Supervisor

A supervisor agent reviews worker outputs and can accept or reject them according to a configurable review policy.

Fields

supervisor: AgentRole

Agent role responsible for review.

workers: Vec<AgentRole>

Agent roles producing work to be reviewed.

review_policy: ReviewPolicy

When and how outputs are reviewed.

Swarm

Agents iterate collaboratively until consensus or a convergence threshold is met.

Fields

roles: Vec<AgentRole>

Agent roles participating in the swarm.

max_iterations: u32

Maximum number of iterations before stopping.

convergence_threshold: f64

Convergence threshold (0.0 – 1.0); iteration stops when reached.

Trait Implementations

impl Clone for CollaborationPattern

fn clone(&self) -> CollaborationPattern

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CollaborationPattern

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CollaborationPattern

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for CollaborationPattern

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.