Conclave Pattern Guide

Multi-expert synthesis orchestration implementing the Mixture-of-Agents approach. Multiple specialized Paladins analyze a task in parallel, then an aggregator synthesizes their diverse perspectives into a comprehensive response.

Overview
Quick Start
Configuration
Programmatic API
YAML Configuration
CLI Usage
Use Cases
Error Handling
Observability
Best Practices
Troubleshooting

Overview

The Conclave pattern solves problems requiring multiple expert perspectives that must be intelligently synthesized. Unlike simple parallel execution (Phalanx), Conclave specifically focuses on combining diverse viewpoints through an aggregator agent.

When to Use Conclave

✅ Use Conclave When:

Decisions benefit from multiple perspectives (technical, business, security, etc.)
You need diverse expert opinions synthesized into actionable recommendations
Different stakeholders have unique concerns that must all be addressed
Quality improves through deliberate multi-perspective analysis

❌ Don't Use Conclave When:

Single perspective is sufficient
All agents would provide identical analysis
Simple parallel processing without synthesis is adequate (use Phalanx instead)
Real-time response is critical (Conclave adds synthesis overhead)

Architecture

                    ┌──────────────┐
                    │   Input      │
                    │   Query      │
                    └──────┬───────┘
                           │
         ┌─────────────────┼─────────────────┐
         │                 │                 │
         ▼                 ▼                 ▼
  ┌─────────────┐   ┌─────────────┐   ┌─────────────┐
  │  Expert 1   │   │  Expert 2   │   │  Expert 3   │
  │ (Technical) │   │ (Business)  │   │ (Security)  │
  └──────┬──────┘   └──────┬──────┘   └──────┬──────┘
         │                 │                 │
         └─────────────────┼─────────────────┘
                           │
                           ▼
                    ┌─────────────┐
                    │ Aggregator  │
                    │  Synthesis  │
                    └──────┬──────┘
                           │
                           ▼
                    ┌─────────────┐
                    │   Final     │
                    │  Response   │
                    └─────────────┘

Key Benefits

Higher Quality Outputs: Multiple perspectives catch blind spots
Comprehensive Analysis: Technical, business, security, etc. all considered
Balanced Decisions: Aggregator weighs competing priorities
Resilience: Continues even if some experts fail
Traceable Reasoning: See each expert's input to final decision

Quick Start

Minimal Example

use paladin::prelude::*;
use paladin::battalion::conclave::*;
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let llm_adapter = Arc::new(OpenAiAdapter::new().build()?);

    // Create 3 experts with different perspectives
    let technical = create_paladin(llm_adapter.clone(),
        "TechnicalExpert",
        "You are a technical architect. Analyze from a technical perspective."
    )?;

    let business = create_paladin(llm_adapter.clone(),
        "BusinessExpert",
        "You are a business strategist. Analyze from a business perspective."
    )?;

    let security = create_paladin(llm_adapter.clone(),
        "SecurityExpert",
        "You are a security expert. Analyze from a security perspective."
    )?;

    // Create aggregator to synthesize expert outputs
    let aggregator = create_paladin(llm_adapter.clone(),
        "Aggregator",
        "Synthesize the expert analyses into a comprehensive recommendation."
    )?;

    // Configure Conclave
    let config = ConclaveConfig::new("expert-panel", BattalionConfig::default())
        .with_timeout(300)
        .with_retry_attempts(2);

    // Build Conclave
    let conclave = Conclave::new(
        vec![technical, business, security],
        aggregator,
        config
    )?;

    // Execute
    let service = ConclaveExecutionService::new(paladin_port);
    let result = service.execute(&conclave,
        "Should we migrate to microservices?"
    ).await?;

    println!("Final Recommendation:\n{}", result.aggregated_output.output);
    Ok(())
}

fn create_paladin(
    llm: Arc<dyn LlmPort>,
    name: &str,
    prompt: &str
) -> Result<Paladin, Box<dyn std::error::Error>> {
    PaladinBuilder::new(llm)
        .name(name)
        .system_prompt(prompt)
        .temperature(0.7)
        .build()
}

Configuration

ConclaveConfig Options

#![allow(unused)]
fn main() {
pub struct ConclaveConfig {
    /// Conclave name (required)
    name: String,

    /// Battalion base configuration
    battalion_config: BattalionConfig,

    /// Maximum execution time (seconds)
    timeout_seconds: u64,

    /// Retry attempts for failed experts (default: 2)
    max_retry_attempts: u32,

    /// Custom synthesis prompt (optional)
    synthesis_prompt: Option<String>,

    /// Include expert names in aggregator input (default: true)
    include_expert_names: bool,

    /// Max tokens per expert before truncation (optional)
    max_expert_tokens: Option<usize>,

    /// Observability level (default: Standard)
    observability: ObservabilityLevel,
}
}

Builder Pattern

#![allow(unused)]
fn main() {
let config = ConclaveConfig::new("my-conclave", battalion_config)
    .with_timeout(600)                    // 10 minutes
    .with_retry_attempts(3)               // Retry up to 3 times
    .with_observability(ObservabilityLevel::Verbose)
    .with_expert_names(true)              // Show expert attribution
    .with_max_expert_tokens(2000)         // Truncate long outputs
    .with_synthesis_prompt(               // Override aggregator prompt
        "Focus only on technical feasibility. YES/NO answer required."
    );
}

Retry Configuration

Conclave uses exponential backoff with jitter for retries:

Attempt 1: 1 second  ± 20% jitter
Attempt 2: 2 seconds ± 20% jitter
Attempt 3: 4 seconds ± 20% jitter
Attempt 4: 8 seconds ± 20% jitter
Attempt 5: 16 seconds ± 20% jitter

Example configuration:

#![allow(unused)]
fn main() {
let config = ConclaveConfig::new("resilient", battalion_config)
    .with_retry_attempts(3)  // Total 4 attempts (1 initial + 3 retries)
    .with_timeout(300);      // Overall timeout for all attempts
}

Observability Levels

#![allow(unused)]
fn main() {
pub enum ObservabilityLevel {
    Minimal,   // Errors and final result only
    Standard,  // Progress updates + timing (default)
    Verbose,   // Detailed logs, individual outputs, retries
}
}

Minimal: Production systems with log aggregation

#![allow(unused)]
fn main() {
.with_observability(ObservabilityLevel::Minimal)
}

Standard: Development and staging (recommended)

#![allow(unused)]
fn main() {
.with_observability(ObservabilityLevel::Standard)
}

Verbose: Debugging and troubleshooting

#![allow(unused)]
fn main() {
.with_observability(ObservabilityLevel::Verbose)
}

Programmatic API

Expert Creation

Create diverse experts with specialized roles:

#![allow(unused)]
fn main() {
// Technical Expert - Focus on implementation details
let technical_expert = PaladinBuilder::new(llm_port.clone())
    .name("TechnicalArchitect")
    .system_prompt(
        "You are a senior technical architect with 15+ years experience \
         in distributed systems. Analyze the proposal focusing on:\n\
         - System architecture and design patterns\n\
         - Scalability and performance\n\
         - Technology stack recommendations\n\
         - Implementation risks and complexity"
    )
    .temperature(0.7)
    .max_loops(3)
    .build()?;

// Business Expert - Focus on ROI and strategy
let business_expert = PaladinBuilder::new(llm_port.clone())
    .name("BusinessStrategist")
    .system_prompt(
        "You are a business strategist and product manager. Analyze focusing on:\n\
         - Market opportunity and competitive positioning\n\
         - Cost-benefit analysis and ROI projections\n\
         - Resource requirements (team, budget, timeline)\n\
         - Stakeholder impact across departments"
    )
    .temperature(0.7)
    .max_loops(3)
    .build()?;

// Security Expert - Focus on risks and compliance
let security_expert = PaladinBuilder::new(llm_port.clone())
    .name("SecurityExpert")
    .system_prompt(
        "You are a security expert specializing in application security. Analyze focusing on:\n\
         - Threat modeling and attack surface\n\
         - Required security controls (auth, encryption, etc.)\n\
         - Compliance requirements (GDPR, SOC 2, HIPAA)\n\
         - Security testing requirements"
    )
    .temperature(0.7)
    .max_loops(3)
    .build()?;
}

Aggregator Creation

The aggregator synthesizes expert outputs:

#![allow(unused)]
fn main() {
let aggregator = PaladinBuilder::new(llm_port.clone())
    .name("SynthesisAggregator")
    .system_prompt(
        "You are a synthesis expert combining multiple perspectives. \
         You receive technical, business, and security analyses. \
         Your synthesis should:\n\
         1. Create an executive summary with clear recommendation\n\
         2. Identify common themes across experts\n\
         3. Highlight unique insights from each perspective\n\
         4. Resolve contradictions by weighing evidence\n\
         5. Provide prioritized action items\n\
         6. Outline critical success factors and risks\n\n\
         Structure with clear sections. Integrate thoughtfully, don't just concatenate."
    )
    .temperature(0.5)  // Lower temperature for consistent synthesis
    .max_loops(2)
    .build()?;
}

Building and Executing

#![allow(unused)]
fn main() {
// Create Conclave
let experts = vec![technical_expert, business_expert, security_expert];

let config = ConclaveConfig::new("expert-panel", BattalionConfig::default())
    .with_timeout(300)
    .with_retry_attempts(2)
    .with_observability(ObservabilityLevel::Standard);

let conclave = Conclave::new(experts, aggregator, config)?;

// Execute
let service = ConclaveExecutionService::new(paladin_port);
let result = service.execute(&conclave,
    "Should we implement real-time WebSocket notifications?"
).await?;

// Access results
println!("Status: {:?}", result.status);
println!("Execution time: {}ms", result.execution_time_ms);
println!("Expert success rate: {}/{}",
    result.successful_expert_count(),
    conclave.expert_count()
);

// Individual expert outputs
for (name, output) in result.expert_outputs.iter() {
    println!("\n{}: {}", name, output.output);
}

// Final synthesized output
println!("\nFinal Recommendation:\n{}", result.aggregated_output.output);
}

Error Handling with Partial Success

#![allow(unused)]
fn main() {
match service.execute(&conclave, input).await {
    Ok(result) => {
        if result.successful_expert_count() < conclave.expert_count() {
            eprintln!("Warning: {} experts failed",
                conclave.expert_count() - result.successful_expert_count());
        }

        // Check aggregation success
        if result.status == ConclaveStatus::Completed {
            println!("Success: {}", result.aggregated_output.output);
        } else {
            eprintln!("Aggregation failed but partial results available");
            for (name, output) in result.expert_outputs.iter() {
                println!("{}: {}", name, output.output);
            }
        }
    }
    Err(ConclaveError::AllExpertsFailed) => {
        eprintln!("Critical: All experts failed");
    }
    Err(e) => {
        eprintln!("Error: {}", e);
    }
}
}

YAML Configuration

Basic YAML Structure

Create conclave.yaml:

type: conclave
name: "expert-panel"

experts:
  - inline:
      name: "TechnicalExpert"
      system_prompt: |
        You are a technical architect...
      model: "gpt-4o"
      temperature: 0.7
      max_loops: 3
      timeout_seconds: 300
      stop_words: []
      provider:
        type: openai

  - inline:
      name: "BusinessExpert"
      system_prompt: |
        You are a business strategist...
      model: "gpt-4o"
      temperature: 0.7
      max_loops: 3
      timeout_seconds: 300
      stop_words: []
      provider:
        type: openai

aggregator:
  inline:
    name: "Aggregator"
    system_prompt: |
      Synthesize expert analyses...
    model: "gpt-4o"
    temperature: 0.5
    max_loops: 2
    timeout_seconds: 300
    stop_words: []
    provider:
      type: openai

timeout_seconds: 300
retry_attempts: 2
include_expert_names: true
observability_level: "standard"

External Paladin References

Reference pre-defined Paladin configs:

type: conclave
name: "expert-panel"

experts:
  - file: "configs/technical_expert.yaml"
  - file: "configs/business_expert.yaml"
  - file: "configs/security_expert.yaml"

aggregator:
  file: "configs/synthesis_aggregator.yaml"

timeout_seconds: 300
retry_attempts: 2

Advanced Options

type: conclave
name: "custom-conclave"

experts:
  - inline:
      # ... expert configs ...

aggregator:
  inline:
    # ... aggregator config ...

# Custom synthesis prompt (overrides aggregator's system_prompt)
synthesis_prompt: |
  Focus ONLY on technical feasibility.
  Provide YES/NO recommendation with brief justification.
  Ignore business and security concerns for this analysis.

# Include expert names in aggregator input
include_expert_names: true

# Truncate expert outputs to 2000 tokens before aggregation
max_expert_output_tokens: 2000

# Verbose logging for debugging
observability_level: "verbose"

# Aggressive retry policy
timeout_seconds: 600
retry_attempts: 3

CLI Usage

Generate Template

Create a new Conclave configuration:

paladin battalion new my-experts --type conclave --output conclave.yaml

This generates a template with 3 experts (Technical, Business, Security) and an aggregator with helpful comments.

Run Conclave

Execute a Conclave configuration:

paladin battalion run --config conclave.yaml --type conclave

You'll be prompted for input:

? Enter task for expert analysis: Should we migrate to microservices?

Output to JSON

Save structured output:

paladin battalion run -c conclave.yaml -t conclave -o result.json

Verbose Mode

See detailed execution logs:

paladin battalion run -c conclave.yaml -t conclave --verbose

Output includes:

Expert execution progress
Individual expert outputs (truncated)
Execution timing
Success/failure rates
Final aggregated output

Use Cases

1. Technical Decision Making

Scenario: Evaluate architectural changes

Experts:

Technical Architect (implementation feasibility)
DevOps Engineer (operational impact)
Security Engineer (security implications)

Input: "Should we adopt Kubernetes for our infrastructure?"

Value: Comprehensive evaluation covering development, operations, and security perspectives.

2. Product Feature Evaluation

Scenario: Prioritize product features

Experts:

Product Manager (market fit, user value)
Engineering Lead (implementation complexity)
Data Scientist (data requirements, ML feasibility)

Input: "Should we build an in-house recommendation engine?"

Value: Balanced view of business value vs. technical effort.

3. Code Review

Scenario: Comprehensive code quality analysis

Experts:

Security Reviewer (vulnerability detection)
Performance Reviewer (optimization opportunities)
Maintainability Reviewer (code quality, patterns)

Input: Code snippet or PR description

Value: Multi-dimensional review catching issues from different angles.

4. Compliance Assessment

Scenario: Evaluate regulatory compliance

Experts:

GDPR Expert (data protection requirements)
SOC 2 Expert (security controls)
Industry Expert (sector-specific regulations)

Input: "Assess compliance requirements for storing health data"

Value: Comprehensive compliance coverage across multiple frameworks.

5. Strategic Planning

Scenario: Long-term strategic decisions

Experts:

Market Analyst (competitive landscape, trends)
Financial Advisor (budget, ROI projections)
Risk Manager (strategic risks, mitigation)

Input: "Should we expand to European markets in 2025?"

Value: Well-rounded strategic recommendation considering multiple stakeholder concerns.

Error Handling

Partial Success Scenarios

Conclave continues even if some experts fail:

#![allow(unused)]
fn main() {
let result = service.execute(&conclave, input).await?;

// Check success rate
let success_rate = result.successful_expert_count() as f64 /
                  conclave.expert_count() as f64;

if success_rate < 0.5 {
    eprintln!("Warning: Less than 50% experts succeeded");
}

// Aggregation proceeds with available expert outputs
if result.status == ConclaveStatus::PartialSuccess {
    println!("Aggregation completed with partial expert data");
}
}

Retry Behavior

Failed experts are automatically retried:

#![allow(unused)]
fn main() {
let config = ConclaveConfig::new("resilient", battalion_config)
    .with_retry_attempts(3)  // Retry up to 3 times
    .with_timeout(300);      // Overall timeout includes retries
}

Retry triggers:

Network timeouts
API rate limits (429 errors)
Temporary service unavailability (503 errors)

No retry for:

Authentication failures (401, 403)
Invalid requests (400)
Not found (404)
Exceeded overall timeout

Error Recovery

#![allow(unused)]
fn main() {
match service.execute(&conclave, input).await {
    Ok(result) => {
        match result.status {
            ConclaveStatus::Completed => {
                // All experts succeeded, aggregation successful
                println!("Success: {}", result.aggregated_output.output);
            }
            ConclaveStatus::PartialSuccess => {
                // Some experts failed, but aggregation succeeded
                println!("Partial success: {}", result.aggregated_output.output);
                log::warn!("Failed experts: {}",
                    conclave.expert_count() - result.successful_expert_count());
            }
            ConclaveStatus::Failed => {
                // Aggregation failed
                log::error!("Aggregation failed");
                // Access individual expert outputs if available
                for (name, output) in result.expert_outputs.iter() {
                    println!("{}: {}", name, output.output);
                }
            }
        }
    }
    Err(ConclaveError::AllExpertsFailed) => {
        log::error!("All experts failed - cannot proceed with aggregation");
    }
    Err(ConclaveError::Timeout(secs)) => {
        log::error!("Execution exceeded {} second timeout", secs);
    }
    Err(e) => {
        log::error!("Unexpected error: {}", e);
    }
}
}

Observability

Logging Levels

Configure observability to match your environment:

Minimal (Production):

#![allow(unused)]
fn main() {
.with_observability(ObservabilityLevel::Minimal)
}

Logs only:

Critical errors
Final execution status
Total execution time

Standard (Staging/Development):

#![allow(unused)]
fn main() {
.with_observability(ObservabilityLevel::Standard)
}

Logs:

Expert execution start/completion
Retry attempts
Partial failure warnings
Aggregation timing
Success/failure counts

Verbose (Debugging):

#![allow(unused)]
fn main() {
.with_observability(ObservabilityLevel::Verbose)
}

Logs:

All Standard logs PLUS:
Individual expert outputs (truncated)
Detailed retry information
Token counts per expert
Timing breakdown by phase

Execution Metrics

Access detailed metrics from results:

#![allow(unused)]
fn main() {
let result = service.execute(&conclave, input).await?;

// Overall metrics
println!("Total time: {}ms", result.execution_time_ms);
println!("Status: {:?}", result.status);

// Expert-level metrics
for (name, expert_result) in result.expert_outputs.iter() {
    println!("{}: {}ms, {} tokens, {} loops",
        name,
        expert_result.execution_time_ms,
        expert_result.token_count,
        expert_result.loop_count
    );
}

// Aggregation metrics
println!("Aggregator: {}ms, {} tokens",
    result.aggregated_output.execution_time_ms,
    result.aggregated_output.token_count
);

// Success rate
println!("Success rate: {}/{}",
    result.successful_expert_count(),
    conclave.expert_count()
);
}

Structured Logging

Integrate with structured logging frameworks:

#![allow(unused)]
fn main() {
use log::{info, warn, error};

let result = service.execute(&conclave, input).await?;

info!(
    "Conclave execution completed";
    "conclave_name" => &conclave.name(),
    "status" => format!("{:?}", result.status),
    "execution_ms" => result.execution_time_ms,
    "expert_count" => conclave.expert_count(),
    "successful_experts" => result.successful_expert_count(),
);

if result.successful_expert_count() < conclave.expert_count() {
    warn!(
        "Partial expert failure";
        "failed_count" => conclave.expert_count() - result.successful_expert_count(),
    );
}
}

Best Practices

Expert Configuration

1. Recommended Number of Experts: 3-5

Minimum 2: Required for diversity
Optimal 3-4: Balanced quality vs. cost/latency
Maximum 5-6: Diminishing returns beyond this

2. Ensure Expert Diversity

❌ Don't create redundant experts:

#![allow(unused)]
fn main() {
let expert1 = create_expert("Expert1", "You are a technical expert");
let expert2 = create_expert("Expert2", "You are a technical expert");
// Same perspective - wasteful!
}

✅ Create distinct perspectives:

#![allow(unused)]
fn main() {
let technical = create_expert("Technical", "Architecture and implementation");
let business = create_expert("Business", "ROI and strategy");
let security = create_expert("Security", "Risks and compliance");
// Different perspectives - valuable diversity
}

3. Use Lower Temperature for Aggregator

Experts can be creative (temperature 0.6-0.8), but aggregator should be consistent:

#![allow(unused)]
fn main() {
// Experts: Creative analysis
let expert = PaladinBuilder::new(llm)
    .temperature(0.7)
    .build()?;

// Aggregator: Consistent synthesis
let aggregator = PaladinBuilder::new(llm)
    .temperature(0.5)  // Lower for consistency
    .build()?;
}

Prompt Engineering

1. Structure Expert Prompts

Use clear sections in system prompts:

#![allow(unused)]
fn main() {
let expert = create_expert(
    "TechnicalExpert",
    "You are a senior technical architect.\n\
     \n\
     Analyze the input focusing on:\n\
     - System architecture and design patterns\n\
     - Scalability and performance considerations\n\
     - Technology stack recommendations\n\
     - Implementation risks and complexity\n\
     \n\
     Provide specific technical details.\n\
     Cite proven patterns and best practices."
);
}

2. Aggregator Synthesis Instructions

Be explicit about synthesis requirements:

#![allow(unused)]
fn main() {
let aggregator = create_expert(
    "Aggregator",
    "Synthesize expert analyses following these steps:\n\
     1. Create executive summary with clear recommendation\n\
     2. Identify common themes across all experts\n\
     3. Highlight unique insights from each perspective\n\
     4. Resolve contradictions by weighing evidence\n\
     5. Provide prioritized action items\n\
     6. Outline critical success factors and risks\n\
     \n\
     DO NOT simply concatenate expert outputs.\n\
     Integrate thoughtfully into coherent narrative."
);
}

3. Use synthesis_prompt for Task-Specific Focus

Override aggregator behavior for specific tasks:

#![allow(unused)]
fn main() {
let config = ConclaveConfig::new("focused", battalion_config)
    .with_synthesis_prompt(
        "Focus ONLY on technical feasibility. \
         Ignore business and security concerns. \
         Provide YES/NO recommendation with 2-3 sentence justification."
    );
}

Performance Optimization

1. Set Appropriate Timeouts

#![allow(unused)]
fn main() {
// Quick analysis
let config = ConclaveConfig::new("quick", battalion_config)
    .with_timeout(60);  // 1 minute

// Thorough analysis
let config = ConclaveConfig::new("thorough", battalion_config)
    .with_timeout(600);  // 10 minutes
}

2. Truncate Verbose Expert Outputs

Prevent token limit issues:

#![allow(unused)]
fn main() {
let config = ConclaveConfig::new("optimized", battalion_config)
    .with_max_expert_tokens(2000);  // Limit per expert
}

3. Parallel Execution is Automatic

Experts execute concurrently - no additional configuration needed.

Cost Management

1. Choose Appropriate Models

#![allow(unused)]
fn main() {
// Experts: Use fast, cost-effective models
let expert = PaladinBuilder::new(llm)
    .model("gpt-4o-mini")  // Cheaper model
    .temperature(0.7)
    .build()?;

// Aggregator: Use more capable model for synthesis
let aggregator = PaladinBuilder::new(llm)
    .model("gpt-4o")  // Better model for complex synthesis
    .temperature(0.5)
    .build()?;
}

2. Limit max_loops

Prevent excessive LLM calls:

#![allow(unused)]
fn main() {
let expert = PaladinBuilder::new(llm)
    .max_loops(2)  // Reasonable limit
    .build()?;
}

3. Monitor Token Usage

#![allow(unused)]
fn main() {
let result = service.execute(&conclave, input).await?;

let total_tokens: usize = result.expert_outputs.values()
    .map(|r| r.token_count)
    .sum::<usize>() + result.aggregated_output.token_count;

println!("Total tokens used: {}", total_tokens);
}

Troubleshooting

Problem: All Experts Fail

Symptoms:

Error: ConclaveError::AllExpertsFailed
No expert outputs in result

Possible Causes:

API key issues
Network connectivity problems
Rate limiting
Invalid model names

Solutions:

#![allow(unused)]
fn main() {
// 1. Verify API keys
std::env::var("OPENAI_API_KEY").expect("API key not set");

// 2. Increase timeout
let config = ConclaveConfig::new("patient", battalion_config)
    .with_timeout(600);  // Longer timeout

// 3. Add more retry attempts
let config = ConclaveConfig::new("persistent", battalion_config)
    .with_retry_attempts(5);

// 4. Enable verbose logging
let config = ConclaveConfig::new("debug", battalion_config)
    .with_observability(ObservabilityLevel::Verbose);
}

Problem: Aggregation Fails Despite Successful Experts

Symptoms:

Expert outputs are present
result.status == ConclaveStatus::Failed
Aggregation error in logs

Possible Causes:

Aggregator timeout (processing combined expert outputs)
Token limit exceeded (too much expert output)
Aggregator model capacity issues

Solutions:

#![allow(unused)]
fn main() {
// 1. Increase aggregator-specific timeout
let aggregator = PaladinBuilder::new(llm)
    .timeout_seconds(600)  // Longer timeout for synthesis
    .build()?;

// 2. Truncate expert outputs
let config = ConclaveConfig::new("limited", battalion_config)
    .with_max_expert_tokens(1500);

// 3. Use more capable aggregator model
let aggregator = PaladinBuilder::new(llm)
    .model("gpt-4o")  // Upgrade from mini
    .build()?;
}

Problem: Poor Quality Synthesis

Symptoms:

Aggregator simply concatenates expert outputs
Missing integration of perspectives
No actionable recommendations

Solutions:

#![allow(unused)]
fn main() {
// 1. Improve aggregator prompt
let aggregator = create_expert(
    "Aggregator",
    "You are a synthesis expert. Your role is to INTEGRATE (not concatenate) \
     the expert analyses. Create a coherent narrative that:\n\
     - Identifies patterns and common themes\n\
     - Highlights contradictions and resolves them\n\
     - Provides clear, actionable recommendations\n\
     - Structures output with sections and bullet points"
);

// 2. Use synthesis_prompt for task-specific guidance
let config = ConclaveConfig::new("guided", battalion_config)
    .with_synthesis_prompt(
        "Combine expert analyses into a single recommendation. \
         Format as: Executive Summary, Key Findings, Recommendation, Next Steps."
    );

// 3. Lower aggregator temperature for consistency
let aggregator = PaladinBuilder::new(llm)
    .temperature(0.3)  // Very consistent
    .build()?;
}

Problem: Slow Execution

Symptoms:

Execution takes longer than expected
Timeout errors

Possible Causes:

Sequential expert execution (shouldn't happen - experts are parallel)
Slow individual experts
Excessive retries

Solutions:

#![allow(unused)]
fn main() {
// 1. Verify parallel execution (automatic, but check logs)
let config = ConclaveConfig::new("fast", battalion_config)
    .with_observability(ObservabilityLevel::Verbose);

// 2. Reduce expert max_loops
let expert = PaladinBuilder::new(llm)
    .max_loops(1)  // Single pass
    .build()?;

// 3. Limit retry attempts
let config = ConclaveConfig::new("quick", battalion_config)
    .with_retry_attempts(1);  // One retry only

// 4. Use faster models
let expert = PaladinBuilder::new(llm)
    .model("gpt-4o-mini")
    .build()?;
}

Problem: Inconsistent Expert Names in Output

Symptoms:

Expert outputs lack attribution
Can't tell which expert said what

Solution:

#![allow(unused)]
fn main() {
let config = ConclaveConfig::new("attributed", battalion_config)
    .with_expert_names(true);  // Ensure this is set
}

Paladin Framework