Overview

Multi-Agent Pipeline

Reviewate uses a multi-agent pipeline powered by the Claude Agent SDK where specialized agents handle different aspects of code review:

PR Diff
  │
  ▼
Issue Explorer
  │  Finds and summarizes linked issues from the PR description
  ▼
2 Analyze Agents (parallel, with tools)
  │  Each explores the codebase via Read/Grep/Glob/Bash
  │  and identifies potential issues
  ▼
Synthesizer
  │  Merges findings from both analyzers
  ▼
Deduplication
  │  Removes issues that duplicate existing human comments
  ▼
Fact Checker
  │  Verifies each claim against actual code
  │  using code search and file reads
  ▼
Style
  │  Makes reviews concise and actionable
  ▼
Guardrail
  │  Scans findings for leaked secrets (gitleaks-based)
  ▼
Post comments

Pipeline Stages

1. Issue Explorer — Finds and summarizes linked issues from the PR description for context
2. 2 Analyze Agents (parallel) — Each uses Read/Grep/Glob/Bash tools to independently explore the codebase and identify issues. Results are merged by the Synthesizer
3. Deduplication — Removes issues that duplicate existing human comments (only when discussions exist)
4. Fact Checker — Independently re-verifies each claim against actual code using the same tools
5. Style Agent — Makes reviews concise and actionable
6. Guardrail — Scans findings for leaked secrets before posting

Why Multiple Agents?

Most AI reviewers use a single prompt ("review this diff"), which leads to hallucinations. Reviewate's approach:

1. Parallel exploration — 2 agents with code search tools independently explore the codebase, finding issues a single pass would miss
2. Adversarial fact-checking — A separate agent with fresh context verifies each claim against actual code
3. High signal, low noise — Only issues that survive fact-checking get posted

Two-Tier Model System

Agents are grouped into tiers to balance quality and cost:

See Model Configuration for model recommendations.

Tech Stack

Monorepo Structure

reviewate/
├── backend/           # FastAPI API server
│   ├── api/           # Plugin-based architecture
│   ├── configs/       # YAML configuration (docker.yaml, kubernetes.yaml)
│   └── Dockerfile
├── frontend/          # Nuxt 4 dashboard
│   ├── app/           # Pages, components, composables
│   └── Dockerfile
├── code_reviewer/     # Multi-agent review engine
│   ├── agents/        # Agent implementations (BaseAgent + specialized)
│   ├── workflows/     # Review and summary pipeline orchestration
│   ├── adaptors/      # GitHub/GitLab handlers (gh/glab CLI)
│   └── prompts/       # Jinja2 prompt templates
├── packages/          # Shared TypeScript SDK generated from the openapi
├── website/           # Marketing site & documentation
└── docker-compose.yml

Backend Plugin Architecture

The backend uses a plugin system where each feature is encapsulated:

• DatabasePlugin — SQLAlchemy database connections and migrations
• GitHubPlugin / GitLabPlugin — OAuth and API clients
• WebServerPlugin — FastAPI routes, CORS, JWT, sessions
• FastStreamPlugin — Redis message broker for async jobs
• ContainerPlugin — Docker/Kubernetes container management and watching

Plugins are configured via YAML files in backend/configs/ and loaded by the Application class.

Composable Deployments

The plugin system enables composable deployments — run the full stack on one server, or split into separate worker pods for scalability. For example, you can deploy a dedicated "worker" pod that only runs the ContainerPlugin + FastStreamPlugin for processing review jobs, while the main pod handles the web server and API.

For questions or custom deployment needs, open an issue or contact adam.saimi@reviewate.com.

Platform Handler Pattern

The code reviewer uses gh and glab CLI tools directly to interact with GitHub and GitLab:

• RepositoryHandler (abstract) — Fetch PRs, diffs, archives; post reviews
• GitHubRepository / GitLabRepository — Concrete implementations using gh api / glab api subprocess calls

This allows the same review pipeline to work with both GitHub and GitLab.