Code Council

One AI can miss things. A council of AIs catches more.

Get Started View on GitHub

Unanimous

When all models agree, you can be confident it's a real issue. Fix it.

Majority

Most models flagged this. Probably worth investigating.

Disagreement

Models conflict. You know exactly where to focus your judgment.

How It Works

Your code goes through multiple models simultaneously

Submit code

Paste or review git

→

4 models analyze

Running in parallel

→

Cluster findings

Group by location

→

Score consensus

Unanimous/majority/split

Available Tools

Each tool runs your input through multiple AI models in parallel

review_code

General code review for bugs, security, performance, and quality issues across any language.

Use review_code to check this function: [paste code]

code* language context output_format

review_frontend

Accessibility, performance, and UX review for React, Vue, Svelte, and other frameworks.

Use review_frontend with review_type=accessibility

code* framework review_type

review_backend

Security-focused review for APIs and servers. Catches auth issues, injection vulnerabilities.

Use review_backend with review_type=security

code* language review_type

review_plan

Review implementation plans BEFORE coding. Catch design issues when they're cheap to fix.

Use review_plan to analyze this plan: [paste]

plan* review_type context

review_git_changes

Review git changes directly. Works with staged, unstaged, branch diffs, or specific commits.

Use review_git_changes with review_type=staged

review_type commit_hash context

discuss_with_council

Multi-turn conversations. Each model maintains its own context for diverse perspectives.

Use discuss_with_council to ask: [question]

message* session_id discussion_type

tps_audit

Toyota Production System analysis. Flow, waste, bottlenecks. Generates HTML reports.

Use tps_audit to analyze this repository

path focus_areas max_files output_format

CLI & GitHub Actions

Run reviews from command line or automate in CI/CD

Quick Setup

# Generate GitHub Actions workflow (with inline PR comments)
npx @klitchevo/code-council setup workflow

# Generate simple markdown workflow
npx @klitchevo/code-council setup workflow --simple

# Overwrite existing workflow
npx @klitchevo/code-council setup workflow --force

Creates .github/workflows/code-council-review.yml automatically.

CLI Review Commands

# Review git changes
npx @klitchevo/code-council review git --review-type diff

# Review with inline PR comments format
npx @klitchevo/code-council review git --format pr-comments

# Review code from stdin
echo "function foo() {}" | npx @klitchevo/code-council review code

# Review with custom models
npx @klitchevo/code-council review git \
  --models "anthropic/claude-sonnet-4,openai/gpt-4o"

GitHub Actions Workflow

Findings appear as inline comments on the exact lines of code in your PR. Code fixes use GitHub's suggestion syntax for one-click apply.

Workflow with Inline PR Comments

name: Code Council Review
on:
  pull_request:
    types: [opened, synchronize, ready_for_review]

jobs:
  review:
    runs-on: ubuntu-latest
    if: github.event.pull_request.draft == false
    permissions:
      contents: read
      pull-requests: write

    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Run Code Council Review
        env:
          OPENROUTER_API_KEY: ${{ secrets.OPENROUTER_API_KEY }}
        run: |
          npx @klitchevo/code-council review git \
            --review-type diff \
            --format pr-comments \
            > review.json

      - name: Post Inline Review
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          gh api repos/${{ github.repository }}/pulls/${{ github.event.pull_request.number }}/reviews \
            --method POST --input review.json

Code suggestions use GitHub's native syntax with "Apply suggestion" button. Re-runs automatically clean up old comments.

CLI Options

Option	Description
`--models "m1,m2"`	Override default models (comma-separated)
`--format`	Output format: markdown (default), json, html, pr-comments
`--context "..."`	Additional context for the review
`--file path`	Read input from file instead of stdin
`--review-type`	For git: staged, unstaged, diff, commit
`--commit hash`	Commit hash (for commit review type)
`--framework`	Frontend framework (react, vue, svelte)
`--language`	Programming language for backend reviews

Setup Commands

Command	Description
`setup workflow`	Generate GitHub Actions workflow for PR reviews
`setup workflow --simple`	Use markdown format (no inline comments)
`setup workflow --force`	Overwrite existing workflow file
`init`	Generate config file (.code-council/config.ts)

Configuration

Config files, environment variables, and customization

Generate Config File

# TypeScript config (recommended)
npx @klitchevo/code-council init

# JavaScript in project root
npx @klitchevo/code-council init --js --root

Creates .code-council/config.ts with full type support.

Example Config

import { defineConfig } from "@klitchevo/code-council/config";

export default defineConfig({
  models: {
    codeReview: ["anthropic/claude-sonnet-4"],
    backendReview: ["openai/gpt-4o"],
  },
  llm: {
    temperature: 0.3,
    maxTokens: 16384,
  },
});

Environment Variables

Variable	Description
`OPENROUTER_API_KEY`	Required. Your OpenRouter API key
`CODE_REVIEW_MODELS`	Models for general reviews (JSON array)
`FRONTEND_REVIEW_MODELS`	Models for frontend reviews
`BACKEND_REVIEW_MODELS`	Models for backend reviews
`TEMPERATURE`	Response randomness (0.0-2.0, default: 0.3)
`MAX_TOKENS`	Max response tokens (default: 16384)

Model Selection

Choose models based on your needs and budget

Why These Defaults?

We picked 4 models that are cheap, fast, and different enough from each other to catch different things. All available through OpenRouter at a fraction of the cost of frontier models. You can swap in Claude or GPT-4 anytime.

Minimax M2.5

Chinese lab model with strong code understanding. Fast inference and very cheap. Good at spotting logical errors and edge cases in business logic.

minimax/minimax-m2.5

GLM 4.7

Zhipu AI's latest model. Trained on diverse multilingual data, which means it sometimes catches patterns Western-trained models miss. Solid at documentation and naming issues.

z-ai/glm-4.7

Kimi K2.5

Moonshot AI's flagship. Known for strong reasoning and 128k context window. Handles large files well and tends to be thorough - sometimes catches security issues others miss.

moonshotai/kimi-k2.5

DeepSeek V3.2

One of the best open-weight models available. Competitive with GPT-4 on coding benchmarks at a fraction of the price. Strong at architecture and design pattern analysis.

deepseek/deepseek-v3.2

Pricing Tiers

Budget (Default)

~$0.01-0.05 per review

["minimax/minimax-m2.5", "deepseek/deepseek-v3.2"]

Balanced

~$0.10-0.30 per review

["anthropic/claude-sonnet-4", "openai/gpt-4o"]

Premium

~$0.50-1.00 per review

["anthropic/claude-opus-4.5", "openai/gpt-4o"]

Quick Start

Add to your Claude Desktop config and start reviewing

{
  "mcpServers": {
    "code-council": {
      "command": "npx",
      "args": ["-y", "@klitchevo/code-council"],
      "env": {
        "OPENROUTER_API_KEY": "your-api-key"
      }
    }
  }
}

Get your API key at openrouter.ai/keys