Multi-model AI consensus system with deliberation, code-aware synthesis, and Devil's Advocate critique

AI Council Proxy orchestrates multiple AI models to deliberate and reach consensus, dramatically improving output quality for complex tasks. Instead of relying on a single model, get the collective intelligence of GPT-4, Claude, Gemini, and others working together.

Use when:

• ✅ Code quality is critical (production deployments)
• ✅ Errors are expensive (medical, legal, financial)
• ✅ You need audit trails (compliance, governance)
• ✅ Latency tolerance > 3 seconds (async workflows)

Don't use when:

• ❌ Simple Q&A or chat (single model is faster/cheaper)
• ❌ Real-time requirements (< 2s latency)
• ❌ High-volume, low-stakes queries

• Unified access to 300+ models via OpenRouter (GPT-4, Claude, Gemini, Llama, Mistral, and more)
• Includes free-tier models for zero-cost operation
• Multi-round peer review and critique
• Graceful degradation on timeout or failures

• Detects code automatically in responses
• Compares functional equivalence (not just text similarity)
• Validates code quality (syntax, security, error handling)
• Selects best implementation instead of concatenating solutions

• Challenges consensus with critical analysis
• Configurable intensity (light/moderate/thorough)
• Separate for code vs. text requests
• Catches edge cases and security vulnerabilities

• PostgreSQL + Redis persistence
• RESTful API with JWT/API key auth
• Rate limiting & idempotency
• Server-Sent Events streaming
• Comprehensive cost tracking
• Health monitoring & analytics

• Docker & Docker Compose
• OpenRouter API key (provides unified access to 300+ models including OpenAI, Anthropic, Google, and free-tier models)

# Clone the repository
git clone https://github.com/alias8818/CouncilRouter.git
cd CouncilRouter

# Copy environment template
cp .env.example .env

# Edit .env and add your OpenRouter API key:
# OPENROUTER_API_KEY=sk-or-v1-...
# JWT_SECRET=your-secret-key-here
#
# Get your OpenRouter API key at: https://openrouter.ai/keys

# Start all services (PostgreSQL, Redis, API)
docker-compose up -d

# Verify it's running
curl http://localhost:3000/health
# {"status":"healthy","timestamp":"2024-..."}

That's it! The API is now running on http://localhost:3000.

Start the web-based admin interface for monitoring and configuration:

# Start the admin dashboard (runs on port 3001)
npm run admin

# Access at: http://localhost:3001

The dashboard provides:

• 📊 Real-time system metrics and performance
• 🌐 Provider health monitoring
• ⚙️ Configuration management
• 💰 Cost tracking and analytics
• 📝 System logs and activity feed

See Admin Dashboard Documentation for details.

curl -X POST http://localhost:3000/api/v1/requests \
  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "Review this function for security issues:\n\nfunction login(username, password) {\n  const query = `SELECT * FROM users WHERE username='\''${username}'\'' AND password='\''${password}'\''`;\n  return db.execute(query);\n}",
    "streaming": false
  }'

Response:

{
  "requestId": "abc-123",
  "status": "completed",
  "consensusDecision": "🚨 CRITICAL SECURITY VULNERABILITIES DETECTED:\n\n1. **SQL Injection** - User input directly interpolated into query\n2. **Plaintext Passwords** - No hashing (use bcrypt)\n3. **No Input Validation** - Missing sanitization\n\nSecure implementation:\n```javascript\nfunction login(username, password) {\n  const query = 'SELECT * FROM users WHERE username = $1';\n  const user = await db.query(query, [username]);\n  if (!user) return null;\n  return bcrypt.compare(password, user.passwordHash);\n}\n```"
}

import { OrchestrationEngine, ConfigurationManager } from 'ai-council-proxy';

const orchestration = new OrchestrationEngine(/* ... */);

const decision = await orchestration.processRequest({
  id: 'request-123',
  query: 'Should we use microservices or monolith for a team of 5 building a SaaS product?',
  timestamp: new Date()
});

console.log(decision.content);
// Synthesized advice from GPT-4, Claude, and Gemini
// with agreement level and confidence score

// Use coding-council preset for code tasks
await configManager.applyPreset('coding-council');
// → Claude 3.5 Sonnet, GPT-4o, Gemini 1.5 Pro
// → 3 deliberation rounds
// → Code-aware synthesis enabled

// Use research-council for deep analysis
await configManager.applyPreset('research-council');
// → GPT-4, Claude Opus, Gemini Pro
// → 4 deliberation rounds
// → Meta-synthesis with strongest moderator

┌─────────────────────────────────────────────────────────────┐
│                        API Gateway                          │
│  (REST API, Auth, Rate Limiting, Streaming, Idempotency)   │
└────────────────┬────────────────────────────────────────────┘
                 │
┌────────────────▼────────────────────────────────────────────┐
│                  Orchestration Engine                       │
│  • Parallel provider requests                               │
│  • Multi-round deliberation                                 │
│  • Timeout handling & graceful degradation                  │
└─┬──────────────┬──────────────┬────────────────────────────┘
  │              │              │
  ▼              ▼              ▼
┌────────────┐ ┌─────────────┐ ┌──────────────────────────┐
│ OpenAI     │ │ Anthropic   │ │ Google                   │
│ Adapter    │ │ Adapter     │ │ Adapter                  │
└────────────┘ └─────────────┘ └──────────────────────────┘
                 │
┌────────────────▼────────────────────────────────────────────┐
│                   Synthesis Engine                          │
│  • Consensus extraction                                     │
│  • Weighted fusion                                          │
│  • Meta-synthesis (moderator)                               │
│  • Code-aware synthesis (functional equivalence)            │
│  • Devil's Advocate critique                                │
└─────────────────────────────────────────────────────────────┘

Quality ▲
        │                  ● AI Council (Research)
   100% │              ●  AI Council (Coding)
        │          ●  AI Council (Balanced)
    90% │      ●  AI Council (Fast)
        │  ●  GPT-4
    80% │ ● GPT-3.5
        └─────────────────────────────────► Cost
          $   $$   $$$  $$$$  $$$$$

# Install dependencies
npm install

# Start PostgreSQL and Redis
# (or use: docker-compose up -d postgres redis)

# Initialize database
psql -U postgres -f database/schema.sql

# Build
npm run build

# Run tests
npm test

# Start development server
npm run dev

CouncilRouter/
├── src/
│   ├── api/              # REST API Gateway
│   ├── orchestration/    # Request coordination
│   ├── providers/        # AI provider adapters
│   ├── synthesis/        # Consensus generation
│   │   ├── engine.ts             # Main synthesis logic
│   │   ├── code-detector.ts      # Code detection
│   │   ├── code-similarity.ts    # Functional equivalence
│   │   ├── code-validator.ts     # Quality validation
│   │   └── devils-advocate.ts    # Critique module
│   ├── session/          # Context management
│   ├── config/           # Configuration + presets
│   └── logging/          # Event tracking
├── database/
│   └── schema.sql        # PostgreSQL schema
├── docs/                 # Comprehensive documentation
├── docker-compose.yml    # Local development setup
└── .env.example          # Configuration template

• Quick Start Guide - Get running in 5 minutes
• API Documentation - REST API reference
• Configuration Guide - Council setup & presets
• Admin Dashboard - Web-based monitoring & management
• Deployment Guide - Production deployment
• Architecture Overview - System design

Contributions welcome! Areas where help is needed:

• 🔌 Provider Adapters - Add Mistral, Cohere, local models
• 🎨 Custom Synthesis Strategies - Domain-specific synthesis
• 📊 Analytics - Enhanced monitoring & visualization
• 📖 Documentation - Tutorials, examples, use cases
• 🐛 Bug Reports - Found an issue? Open an issue!

See CONTRIBUTING.md for guidelines.

• Streaming synthesis - Real-time consensus updates
• Custom model rankings - Learn from your usage patterns
• Multi-modal support - Images, audio, video
• Local model support - Llama, Mistral via Ollama
• Web UI - Visual council configuration
• Plugins system - Custom synthesis strategies

Deploy as a GitHub Action to review PRs with multiple AI models, catching bugs before merge.

Law firms use research-council preset to analyze contracts with multiple perspectives and audit trail.

Hospitals synthesize diagnostic recommendations from multiple AI models for safety-critical decisions.

Social platforms use council consensus to make nuanced moderation decisions.

Built with:

• Express - Web framework
• PostgreSQL - Database
• Redis - Caching
• TypeScript - Type safety
• Jest & fast-check - Testing

Inspired by research in ensemble learning, wisdom of crowds, and multi-agent systems.

MIT License - see LICENSE file for details.

• Issues: GitHub Issues
• Discussions: GitHub Discussions